Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
34.05% covered (danger)
34.05%
874 / 2567
5.88% covered (danger)
5.88%
3 / 51
CRAP
0.00% covered (danger)
0.00%
0 / 1
AppController
34.00% covered (danger)
34.00%
872 / 2565
5.88% covered (danger)
5.88%
3 / 51
223049.56
0.00% covered (danger)
0.00%
0 / 1
 processSGF
73.58% covered (warning)
73.58%
39 / 53
0.00% covered (danger)
0.00%
0 / 1
19.15
 xFlip
75.00% covered (warning)
75.00%
3 / 4
0.00% covered (danger)
0.00%
0 / 1
2.06
 yFlip
75.00% covered (warning)
75.00%
3 / 4
0.00% covered (danger)
0.00%
0 / 1
2.06
 getInitialPositionEnd
62.50% covered (warning)
62.50%
5 / 8
0.00% covered (danger)
0.00%
0 / 1
3.47
 getInitialPosition
50.00% covered (danger)
50.00%
10 / 20
0.00% covered (danger)
0.00%
0 / 1
10.50
 getInvisibleSets
0.00% covered (danger)
0.00%
0 / 8
0.00% covered (danger)
0.00%
0 / 1
12
 getDeletedSets
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
12
 startPageUpdate
88.89% covered (warning)
88.89%
16 / 18
0.00% covered (danger)
0.00%
0 / 1
5.03
 uotd
0.00% covered (danger)
0.00%
0 / 157
0.00% covered (danger)
0.00%
0 / 1
2070
 deleteUnusedStatuses
0.00% covered (danger)
0.00%
0 / 40
0.00% covered (danger)
0.00%
0 / 1
72
 saveSolvedNumber
0.00% covered (danger)
0.00%
0 / 32
0.00% covered (danger)
0.00%
0 / 1
156
 resetUserElos
0.00% covered (danger)
0.00%
0 / 14
0.00% covered (danger)
0.00%
0 / 1
12
 handleContribution
52.94% covered (warning)
52.94%
9 / 17
0.00% covered (danger)
0.00%
0 / 1
2.42
 getAllTags
96.55% covered (success)
96.55%
28 / 29
0.00% covered (danger)
0.00%
0 / 1
7
 deleteUserBoards
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 halfXP
0.00% covered (danger)
0.00%
0 / 11
0.00% covered (danger)
0.00%
0 / 1
30
 getNewTsumego
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
12
 publishSingle
0.00% covered (danger)
0.00%
0 / 45
0.00% covered (danger)
0.00%
0 / 1
30
 getTsumegoOfTheDay
0.00% covered (danger)
0.00%
0 / 104
0.00% covered (danger)
0.00%
0 / 1
1190
 ratingMatch
0.00% covered (danger)
0.00%
0 / 62
0.00% covered (danger)
0.00%
0 / 1
992
 rating2
0.00% covered (danger)
0.00%
0 / 22
0.00% covered (danger)
0.00%
0 / 1
132
 encrypt
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
1
 decrypt
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
2
 checkPictureLarge
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
12
 checkPicture
66.67% covered (warning)
66.67%
2 / 3
0.00% covered (danger)
0.00%
0 / 1
3.33
 getTsumegoRankx
0.00% covered (danger)
0.00%
0 / 42
0.00% covered (danger)
0.00%
0 / 1
506
 adjustElo
0.00% covered (danger)
0.00%
0 / 23
0.00% covered (danger)
0.00%
0 / 1
132
 getTsumegoElo
60.38% covered (warning)
60.38%
32 / 53
0.00% covered (danger)
0.00%
0 / 1
95.70
 getTsumegoRankVal
0.00% covered (danger)
0.00%
0 / 41
0.00% covered (danger)
0.00%
0 / 1
506
 getTsumegoRankMax
0.00% covered (danger)
0.00%
0 / 41
0.00% covered (danger)
0.00%
0 / 1
506
 saveDanSolveCondition
100.00% covered (success)
100.00%
18 / 18
100.00% covered (success)
100.00%
1 / 1
7
 updateSprintCondition
94.44% covered (success)
94.44%
17 / 18
0.00% covered (danger)
0.00%
0 / 1
4.00
 updateGoldenCondition
94.12% covered (success)
94.12%
16 / 17
0.00% covered (danger)
0.00%
0 / 1
3.00
 setPotionCondition
0.00% covered (danger)
0.00%
0 / 14
0.00% covered (danger)
0.00%
0 / 1
6
 updateGems
3.85% covered (danger)
3.85%
4 / 104
0.00% covered (danger)
0.00%
0 / 1
2183.48
 checkProblemNumberAchievements
42.39% covered (danger)
42.39%
39 / 92
0.00% covered (danger)
0.00%
0 / 1
166.38
 checkDanSolveAchievements
46.82% covered (danger)
46.82%
81 / 173
0.00% covered (danger)
0.00%
0 / 1
545.62
 checkForLocked
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
20
 checkNoErrorAchievements
50.77% covered (warning)
50.77%
33 / 65
0.00% covered (danger)
0.00%
0 / 1
51.48
 checkTimeModeAchievements
35.40% covered (danger)
35.40%
40 / 113
0.00% covered (danger)
0.00%
0 / 1
2273.83
 checkRatingAchievements
54.44% covered (warning)
54.44%
49 / 90
0.00% covered (danger)
0.00%
0 / 1
95.92
 checkLevelAchievements
72.22% covered (warning)
72.22%
65 / 90
0.00% covered (danger)
0.00%
0 / 1
42.63
 checkSetCompletedAchievements
19.72% covered (danger)
19.72%
14 / 71
0.00% covered (danger)
0.00%
0 / 1
166.54
 setAchievementSpecial
0.00% covered (danger)
0.00%
0 / 184
0.00% covered (danger)
0.00%
0 / 1
4160
 checkSetAchievements
18.10% covered (danger)
18.10%
40 / 221
0.00% covered (danger)
0.00%
0 / 1
2533.09
 getXPJump
0.00% covered (danger)
0.00%
0 / 15
0.00% covered (danger)
0.00%
0 / 1
72
 updateXP
60.00% covered (warning)
60.00%
6 / 10
0.00% covered (danger)
0.00%
0 / 1
3.58
 getPartitionRange
0.00% covered (danger)
0.00%
0 / 22
0.00% covered (danger)
0.00%
0 / 1
56
 handleSearchSettings
100.00% covered (success)
100.00%
13 / 13
100.00% covered (success)
100.00%
1 / 1
2
 signIn
83.33% covered (warning)
83.33%
5 / 6
0.00% covered (danger)
0.00%
0 / 1
2.02
 beforeFilter
83.28% covered (warning)
83.28%
279 / 335
0.00% covered (danger)
0.00%
0 / 1
94.55
 afterFilter
n/a
0 / 0
n/a
0 / 0
1
1<?php
2
3App::uses('Auth', 'Utility');
4App::uses('TsumegoFilters', 'Utility');
5
6class AppController extends Controller {
7    public $viewClass = 'App';
8
9    public $components = [
10        'Session',
11        //'DebugKit.Toolbar',
12        'Flash',
13        'PlayResultProcessor',
14        'TimeMode',
15    ];
16
17    public static function processSGF($sgf) {
18        $aw = strpos($sgf, 'AW');
19        $ab = strpos($sgf, 'AB');
20        $boardSizePos = strpos($sgf, 'SZ');
21        $boardSize = 19;
22        $sgfArr = str_split($sgf);
23        if ($boardSizePos !== false) {
24            $boardSize = $sgfArr[$boardSizePos + 3] . '' . $sgfArr[$boardSizePos + 4];
25        }
26        if (substr($boardSize, 1) == ']') {
27            $boardSize = substr($boardSize, 0, 1);
28        }
29
30        $black = AppController::getInitialPosition($ab, $sgfArr, 'x');
31        $white = AppController::getInitialPosition($aw, $sgfArr, 'o');
32        $stones = array_merge($black, $white);
33
34        $board = [];
35        for ($i = 0; $i < 19; $i++) {
36            $board[$i] = [];
37            for ($j = 0; $j < 19; $j++) {
38                $board[$i][$j] = '-';
39            }
40        }
41        $lowestX = 18;
42        $lowestY = 18;
43        $highestX = 0;
44        $highestY = 0;
45        $stonesCount = count($stones);
46        for ($i = 0; $i < $stonesCount; $i++) {
47            if ($stones[$i][0] < $lowestX) {
48                $lowestX = $stones[$i][0];
49            }
50            if ($stones[$i][0] > $highestX) {
51                $highestX = $stones[$i][0];
52            }
53            if ($stones[$i][1] < $lowestY) {
54                $lowestY = $stones[$i][1];
55            }
56            if ($stones[$i][1] > $highestY) {
57                $highestY = $stones[$i][1];
58            }
59        }
60        if (18 - $lowestX < $lowestX) {
61            $stones = AppController::xFlip($stones);
62        }
63        if (18 - $lowestY < $lowestY) {
64            $stones = AppController::yFlip($stones);
65        }
66        $highestX = 0;
67        $highestY = 0;
68        $stonesCount = count($stones);
69        for ($i = 0; $i < $stonesCount; $i++) {
70            if ($stones[$i][0] > $highestX) {
71                $highestX = $stones[$i][0];
72            }
73            if ($stones[$i][1] > $highestY) {
74                $highestY = $stones[$i][1];
75            }
76            $board[$stones[$i][0]][$stones[$i][1]] = $stones[$i][2];
77        }
78        $tInfo = [];
79        $tInfo[0] = $highestX;
80        $tInfo[1] = $highestY;
81        $arr = [];
82        $arr[0] = $board;
83        $arr[1] = $stones;
84        $arr[2] = $tInfo;
85        $arr[3] = $boardSize;
86
87        return $arr;
88    }
89
90    public static function xFlip($stones) {
91        $stonesCount = count($stones);
92        for ($i = 0; $i < $stonesCount; $i++) {
93            $stones[$i][0] = 18 - $stones[$i][0];
94        }
95
96        return $stones;
97    }
98
99    public static function yFlip($stones) {
100        $stonesCount = count($stones);
101        for ($i = 0; $i < $stonesCount; $i++) {
102            $stones[$i][1] = 18 - $stones[$i][1];
103        }
104
105        return $stones;
106    }
107
108    public static function getInitialPositionEnd($pos, $sgfArr) {
109        $endCondition = 0;
110        $currentPos1 = $pos + 2;
111        $currentPos2 = $pos + 5;
112        while ($sgfArr[$currentPos1] == '[' && $sgfArr[$currentPos2] == ']') {
113            $endCondition = $currentPos2;
114            $currentPos1 += 4;
115            $currentPos2 += 4;
116        }
117
118        return $endCondition;
119    }
120
121    public static function getInitialPosition($pos, $sgfArr, $color) {
122        $arr = [];
123        $end = AppController::getInitialPositionEnd($pos, $sgfArr);
124        for ($i = $pos + 2; $i < $end; $i++) {
125            if ($sgfArr[$i] != '[' && $sgfArr[$i] != ']') {
126                array_push($arr, strtolower($sgfArr[$i]));
127            }
128        }
129        $alphabet = array_flip(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']);
130        $xy = true;
131        $arr2 = [];
132        $c = 0;
133        $arrCount = count($arr);
134        for ($i = 0; $i < $arrCount; $i++) {
135            $arr[$i] = $alphabet[$arr[$i]];
136            if ($xy) {
137                $arr2[$c] = [];
138                $arr2[$c][0] = $arr[$i];
139            } else {
140                $arr2[$c][1] = $arr[$i];
141                $arr2[$c][2] = $color;
142                $c++;
143            }
144            $xy = !$xy;
145        }
146
147        return $arr2;
148    }
149
150    protected function getInvisibleSets() {
151        $this->loadModel('Set');
152        $invisibleSets = [];
153        $in = $this->Set->find('all', ['conditions' => ['public' => 0]]);
154        if (!$in) {
155            $in = [];
156        }
157        foreach ($in as $item) {
158            $invisibleSets[] = $item['Set']['id'];
159        }
160
161        return $invisibleSets;
162    }
163
164    protected function getDeletedSets() {
165        $dSets = [];
166        $de = $this->Set->find('all', ['conditions' => ['public' => -1]]);
167        if (!$de) {
168            $de = [];
169        }
170        foreach ($de as $item) {
171            $dSets[] = $item['Set']['id'];
172        }
173
174        return $dSets;
175    }
176
177    /**
178     * @return void
179     */
180    public static function startPageUpdate() {
181        $str = '';
182        $latest = ClassRegistry::init('AchievementStatus')->find('all', ['limit' => 7, 'order' => 'created DESC']);
183        if (!$latest) {
184            $latest = [];
185        }
186        $latestCount = count($latest);
187        for ($i = 0; $i < $latestCount; $i++) {
188            $a = ClassRegistry::init('Achievement')->findById($latest[$i]['AchievementStatus']['achievement_id']);
189            $u = ClassRegistry::init('User')->findById($latest[$i]['AchievementStatus']['user_id']);
190            if (substr($u['User']['name'], 0, 3) == 'g__' && $u['User']['external_id'] != null) {
191                $startPageUser = AppController::checkPicture($u);
192            } else {
193                $startPageUser = $u['User']['name'];
194            }
195            $latest[$i]['AchievementStatus']['name'] = $a['Achievement']['name'];
196            $latest[$i]['AchievementStatus']['color'] = $a['Achievement']['color'];
197            $latest[$i]['AchievementStatus']['image'] = $a['Achievement']['image'];
198            $latest[$i]['AchievementStatus']['user'] = $startPageUser;
199            $str .= '<div class="quote1"><div class="quote1a"><a href="/achievements/view/' . $a['Achievement']['id'] . '"><img src="/img/' . $a['Achievement']['image'] . '.png" width="34px"></a></div>';
200            $str .= '<div class="quote1b">Achievement gained by ' . $startPageUser . ':<br><div class=""><b>' . $a['Achievement']['name'] . '</b></div></div></div>';
201        }
202        file_put_contents('mainPageAjax.txt', $str);
203    }
204
205    /**
206     * @return void
207     */
208    protected function uotd() { //routine1
209        $this->loadModel('User');
210        $this->loadModel('DayRecord');
211        $this->loadModel('TsumegoAttempt');
212        $this->loadModel('Achievement');
213        $this->loadModel('AchievementCondition');
214        $today = date('Y-m-d');
215        $ux2 = $this->User->find('all', [
216            'limit' => '8',
217            'order' => 'reuse3 DESC',
218            'conditions' => [
219                'NOT' => ['id' => [33]],
220            ],
221        ]);
222        if (!$ux2) {
223            $ux2 = [];
224        }
225        $last = $this->DayRecord->find('all', ['limit' => '7', 'order' => 'date DESC']);
226        if (!$last) {
227            $last = [];
228        }
229        $lastUotds = [];
230        $lastUsers = [];
231        foreach ($last as $item) {
232            $lastUotds[] = $item['DayRecord']['user_id'];
233        }
234        foreach ($ux2 as $item) {
235            $lastUsers[] = $item['User']['id'];
236        }
237        $resultUser = 72;
238        $lastUsersCount = count($lastUsers);
239        for ($i = 0; $i < $lastUsersCount; $i++) {
240            $foundUser = false;
241            $lastUotdsCount = count($lastUotds);
242            for ($j = 0; $j < $lastUotdsCount; $j++) {
243                if ($lastUsers[$i] == $lastUotds[$j]) {
244                    $foundUser = true;
245                }
246            }
247            if (!$foundUser) {
248                $resultUser = $lastUsers[$i];
249
250                break;
251            }
252        }
253        $ux = $this->User->findById($resultUser);
254
255        $recentlyUsed = [];
256        $d = 1;
257        while ($d <= 10) {
258            $ru = $this->DayRecord->find('first', ['conditions' => ['date' => date('Y-m-d', strtotime('-' . $d . ' days'))]]);
259            if ($ru) {
260                array_push($recentlyUsed, $ru);
261            }
262            $d++;
263        }
264        $currentQuote = 'q01';
265        $newQuote = 'q01';
266        $quoteChosen = false;
267        while (!$quoteChosen) {
268            $newQuote = rand(1, 45);
269            if ($newQuote < 10) {
270                $newQuote = 'q0' . $newQuote;
271            } else {
272                $newQuote = 'q' . $newQuote;
273            }
274
275            $f = false;
276            $recentlyUsedCount = count($recentlyUsed);
277            for ($i = 0; $i < $recentlyUsedCount; $i++) {
278                if ($newQuote == $recentlyUsed[$i]['DayRecord']['quote']) {
279                    $f = true;
280                }
281            }
282            if (!$f) {
283                $quoteChosen = true;
284            }
285        }
286        $currentQuote = $newQuote;
287        $dayUserRand = 1;
288        $uotdChosen = false;
289        while (!$uotdChosen) {
290            $dayUserRand = rand(1, 39);
291            $f = false;
292            $recentlyUsedCount = count($recentlyUsed);
293            for ($i = 0; $i < $recentlyUsedCount; $i++) {
294                if ($dayUserRand == $recentlyUsed[$i]['DayRecord']['userbg']) {
295                    $f = true;
296                }
297            }
298            if (!$f) {
299                $uotdChosen = true;
300            }
301        }
302        $activity = $this->TsumegoAttempt->find('all', ['limit' => 40000, 'conditions' => ['DATE(TsumegoAttempt.created)' => date('Y-m-d', strtotime('yesterday'))]]);
303        if (!$activity) {
304            $activity = [];
305        }
306        $visitedProblems = count($activity);
307
308        //how many users today
309        $usersNum = [];
310        $activity = $this->User->find('all', ['limit' => 400, 'order' => 'created DESC']);
311        if (!$activity) {
312            $activity = [];
313        }
314        $activityCount = count($activity);
315        for ($i = 0; $i < $activityCount; $i++) {
316            $a = new DateTime($activity[$i]['User']['created']);
317            if ($a->format('Y-m-d') == $today) {
318                array_push($usersNum, $activity[$i]['User']);
319            }
320        }
321        $gemRand1 = rand(0, 2);
322        $gemRand2 = rand(0, 2);
323        $gemRand3 = rand(0, 2);
324
325        $arch1 = ClassRegistry::init('Achievement')->findById(111);
326        if ($gemRand1 == 0) {
327            $arch1['Achievement']['description'] = 'Has a chance to trigger once a day on an easy ddk problem.';
328        } elseif ($gemRand1 == 1) {
329            $arch1['Achievement']['description'] = 'Has a chance to trigger once a day on a regular ddk problem.';
330        } elseif ($gemRand1 == 2) {
331            $arch1['Achievement']['description'] = 'Has a chance to trigger once a day on a difficult ddk problem.';
332        }
333        ClassRegistry::init('Achievement')->save($arch1);
334        $arch2 = ClassRegistry::init('Achievement')->findById(112);
335        if ($gemRand2 == 0) {
336            $arch2['Achievement']['description'] = 'Has a chance to trigger once a day on an easy sdk problem.';
337        } elseif ($gemRand2 == 1) {
338            $arch2['Achievement']['description'] = 'Has a chance to trigger once a day on a regular sdk problem.';
339        } elseif ($gemRand2 == 2) {
340            $arch2['Achievement']['description'] = 'Has a chance to trigger once a day on a difficult sdk problem.';
341        }
342        ClassRegistry::init('Achievement')->save($arch2);
343        $arch3 = ClassRegistry::init('Achievement')->findById(113);
344        if ($gemRand3 == 0) {
345            $arch3['Achievement']['description'] = 'Has a chance to trigger once a day on an easy dan problem.';
346        } elseif ($gemRand3 == 1) {
347            $arch3['Achievement']['description'] = 'Has a chance to trigger once a day on a regular dan problem.';
348        } elseif ($gemRand3 == 2) {
349            $arch3['Achievement']['description'] = 'Has a chance to trigger once a day on a difficult dan problem.';
350        }
351        ClassRegistry::init('Achievement')->save($arch3);
352
353        $this->DayRecord->create();
354        $dateUser = [];
355        $dateUser['DayRecord']['user_id'] = $ux['User']['id'];
356        $dateUser['DayRecord']['date'] = $today;
357        $dateUser['DayRecord']['solved'] = $ux['User']['reuse3'];
358        $dateUser['DayRecord']['quote'] = $currentQuote;
359        $dateUser['DayRecord']['userbg'] = $dayUserRand;
360        $dateUser['DayRecord']['tsumego'] = $this->getTsumegoOfTheDay();
361        $dateUser['DayRecord']['newTsumego'] = $this->getNewTsumego();
362        $dateUser['DayRecord']['usercount'] = count($usersNum);
363        $dateUser['DayRecord']['visitedproblems'] = $visitedProblems;
364        $dateUser['DayRecord']['gems'] = $gemRand1 . '-' . $gemRand2 . '-' . $gemRand3;
365        $dateUser['DayRecord']['gemCounter1'] = 0;
366        $dateUser['DayRecord']['gemCounter2'] = 0;
367        $dateUser['DayRecord']['gemCounter3'] = 0;
368        $this->DayRecord->save($dateUser);
369
370        ClassRegistry::init('AchievementCondition')->create();
371        $achievementCondition = [];
372        $achievementCondition['AchievementCondition']['user_id'] = $ux['User']['id'];
373        $achievementCondition['AchievementCondition']['set_id'] = 0;
374        $achievementCondition['AchievementCondition']['category'] = 'uotd';
375        $achievementCondition['AchievementCondition']['value'] = 1;
376        ClassRegistry::init('AchievementCondition')->save($achievementCondition);
377
378        //delete duplicated DayRecords
379        $dr = $this->DayRecord->find('all');
380        if (!$dr) {
381            $dr = [];
382        }
383        $duplicates = [];
384        $drCount = count($dr);
385        for ($i = 0; $i < $drCount; $i++) {
386            $alreadyFound = [];
387            for ($j = 0; $j < $drCount; $j++) {
388                if ($i != $j && $dr[$j]['DayRecord']['date'] == $dr[$i]['DayRecord']['date']) {
389                    $found = false;
390                    $alreadyFoundCount = count($alreadyFound);
391                    for ($k = 0; $k < $alreadyFoundCount; $k++) {
392                        if ($alreadyFound[$k]['DayRecord']['id'] == $dr[$i]['DayRecord']['id'] || $alreadyFound[$k]['DayRecord']['id'] == $dr[$j]['DayRecord']['id']) {
393                            $found = true;
394                        }
395                    }
396                    if (!$found) {
397                        array_push($duplicates, $dr[$i]['DayRecord']['date']);
398                        array_push($alreadyFound, $dr[$i]);
399                    }
400                }
401            }
402        }
403        $duplicates = array_count_values($duplicates);
404        foreach ($duplicates as $key => $value) {
405            while ($duplicates[$key] > 1) {
406                $drd = $this->DayRecord->find('first', ['conditions' => ['date' => $key]]);
407                if ($drd) {
408                    $this->DayRecord->delete($drd['DayRecord']['id']);
409                }
410                $duplicates[$key]--;
411            }
412        }
413    }
414
415    public static function deleteUnusedStatuses(int $uid): void {
416        $s = ClassRegistry::init('Set')->find('all', [
417            'conditions' => [
418                'OR' => [
419                    ['public' => 1],
420                    ['public' => 0],
421                ],
422            ],
423        ]) ?: [];
424        $ids = [];
425        $sCount = count($s);
426        for ($i = 0; $i < $sCount; $i++) {
427            $tSet = TsumegoUtil::collectTsumegosFromSet($s[$i]['Set']['id']);
428            foreach ($tSet as $item) {
429                $ids[] = $item['Tsumego']['id'];
430            }
431        }
432        $ut = ClassRegistry::init('TsumegoStatus')->find('all', [
433            'conditions' => [
434                'user_id' => $uid,
435                'NOT' => [
436                    'tsumego_id' => $ids,
437                ],
438            ],
439        ]);
440        if (!$ut) {
441            $ut = [];
442        }
443        $utCount = count($ut);
444        for ($i = 0; $i < $utCount; $i++) {
445            $test1 = ClassRegistry::init('Tsumego')->findById($ut[$i]['TsumegoStatus']['tsumego_id']);
446            $test2 = ClassRegistry::init('SetConnection')->find('first', ['conditions' => ['tsumego_id' => $test1['Tsumego']['id']]]);
447            if (!$test2) {
448                ClassRegistry::init('TsumegoStatus')->delete($ut[$i]['TsumegoStatus']['id']);
449
450                continue;
451            }
452            $test3 = ClassRegistry::init('Set')->find('first', [
453                'id' => $test2['SetConnection']['set_id'],
454                'OR' => [
455                    ['public' => 1],
456                    ['public' => 0],
457                ],
458            ]);
459            if ($test3 == null) {
460                ClassRegistry::init('TsumegoStatus')->delete($ut[$i]['TsumegoStatus']['id']);
461            }
462        }
463    }
464
465    protected function saveSolvedNumber($uid) {
466        $this->loadModel('User');
467        $this->loadModel('TsumegoStatus');
468        $this->loadModel('Set');
469        $this->loadModel('SetConnection');
470
471        $solvedUts2 = 0;
472        $tsumegos = $this->SetConnection->find('all');
473        if (!$tsumegos) {
474            $tsumegos = [];
475        }
476        $uts = $this->TsumegoStatus->find('all', ['order' => 'created DESC', 'conditions' => ['user_id' => $uid]]);
477        if (!$uts) {
478            $uts = [];
479        }
480        $setKeys = [];
481        $setArray = $this->Set->find('all', ['conditions' => ['public' => 1]]);
482        if (!$setArray) {
483            $setArray = [];
484        }
485
486        $setArrayCount = count($setArray);
487        for ($i = 0; $i < $setArrayCount; $i++) {
488            $setKeys[$setArray[$i]['Set']['id']] = $setArray[$i]['Set']['id'];
489        }
490
491        $scs = [];
492        $tsumegosCount = count($tsumegos);
493        for ($j = 0; $j < $tsumegosCount; $j++) {
494            if (!isset($scs[$tsumegos[$j]['SetConnection']['tsumego_id']])) {
495                $scs[$tsumegos[$j]['SetConnection']['tsumego_id']] = 1;
496            } else {
497                $scs[$tsumegos[$j]['SetConnection']['tsumego_id']]++;
498            }
499        }
500        $utsCount = count($uts);
501        for ($j = 0; $j < $utsCount; $j++) {
502            if ($uts[$j]['TsumegoStatus']['status'] == 'S' || $uts[$j]['TsumegoStatus']['status'] == 'W' || $uts[$j]['TsumegoStatus']['status'] == 'C') {
503                if (isset($scs[$uts[$j]['TsumegoStatus']['tsumego_id']])) {
504                    $solvedUts2 += $scs[$uts[$j]['TsumegoStatus']['tsumego_id']];
505                }
506            }
507        }
508        Auth::getUser()['solved'] = $solvedUts2;
509        Auth::saveUser();
510
511        return $solvedUts2;
512    }
513
514    /**
515     * @return void
516     */
517    protected function resetUserElos() {
518        $this->loadModel('User');
519
520        $u = $this->User->find('all', [
521            'conditions' => [
522                'id >=' => 15000,
523                'id <=' => 19000,
524            ],
525        ]);
526        if (!$u) {
527            $u = [];
528        }
529
530        $uCount = count($u);
531        for ($i = 0; $i < $uCount; $i++) {
532            $u[$i]['User']['rating'] = 900;
533            $u[$i]['User']['solved2'] = 0;
534            $this->User->save($u[$i]);
535        }
536    }
537
538    /**
539     * @param int $uid User ID
540     * @param string $action Action type
541     *
542     * @return void
543     */
544    public static function handleContribution($uid, $action) {
545        $uc = ClassRegistry::init('UserContribution')->find('first', ['conditions' => ['user_id' => $uid]]);
546        if ($uc == null) {
547            $uc = [];
548            $uc['UserContribution']['user_id'] = $uid;
549            $uc['UserContribution']['added_tag'] = 0;
550            $uc['UserContribution']['created_tag'] = 0;
551            $uc['UserContribution']['made_proposal'] = 0;
552            $uc['UserContribution']['reviewed'] = 0;
553            $uc['UserContribution']['score'] = 0;
554            ClassRegistry::init('UserContribution')->create();
555        }
556        $uc['UserContribution'][$action] += 1;
557        $uc['UserContribution']['score']
558        = $uc['UserContribution']['added_tag']
559        + $uc['UserContribution']['created_tag'] * 3
560        + $uc['UserContribution']['made_proposal'] * 5
561        + $uc['UserContribution']['reviewed'] * 2;
562        ClassRegistry::init('UserContribution')->save($uc);
563    }
564
565    public static function getAllTags($not) {
566        $a = [];
567        $notApproved = ClassRegistry::init('TagName')->find('all', ['conditions' => ['approved' => 0]]);
568        if (!$notApproved) {
569            $notApproved = [];
570        }
571        $notCount = count($not);
572        for ($i = 0; $i < $notCount; $i++) {
573            array_push($a, $not[$i]['Tag']['tag_name_id']);
574        }
575        $notApprovedCount = count($notApproved);
576        for ($i = 0; $i < $notApprovedCount; $i++) {
577            array_push($a, $notApproved[$i]['TagName']['id']);
578        }
579        $tn = ClassRegistry::init('TagName')->find('all', [
580            'conditions' => [
581                'NOT' => ['id' => $a],
582            ],
583        ]);
584        if (!$tn) {
585            $tn = [];
586        }
587        $sorted = [];
588        $keys = [];
589        $tnCount = count($tn);
590        for ($i = 0; $i < $tnCount; $i++) {
591            array_push($sorted, $tn[$i]['TagName']['name']);
592            $keys[$tn[$i]['TagName']['name']] = $tn[$i];
593        }
594        sort($sorted);
595        $s2 = [];
596        $sortedCount = count($sorted);
597        for ($i = 0; $i < $sortedCount; $i++) {
598            array_push($s2, $keys[$sorted[$i]]);
599        }
600
601        return $s2;
602    }
603
604    /**
605     * @return void
606     */
607    protected function deleteUserBoards() {
608        $this->loadModel('UserBoard');
609        $this->UserBoard->deleteAll(['1 = 1']);
610    }
611
612    /**
613     * @return void
614     */
615    protected function halfXP() {
616        $this->loadModel('TsumegoStatus');
617        $this->loadModel('DayRecord');
618        $week = $this->TsumegoStatus->find('all', ['order' => 'created DESC', 'conditions' => ['status' => 'S']]);
619        if (!$week) {
620            $week = [];
621        }
622        $oneWeek = date('Y-m-d H:i:s', strtotime('-7 days'));
623        $weekCount = count($week);
624        for ($i = 0; $i < $weekCount; $i++) {
625            if ($week[$i]['TsumegoStatus']['created'] < $oneWeek) {
626                if ($week[$i]['TsumegoStatus']['status'] == 'S') {
627                    $week[$i]['TsumegoStatus']['status'] = 'W';
628                    //$this->TsumegoStatus->save($week[$i]);
629                }
630            }
631        }
632    }
633
634    protected function getNewTsumego() {
635        $this->loadModel('Schedule');
636        $date = date('Y-m-d', strtotime('today'));
637        $s = $this->Schedule->find('all', ['conditions' => ['date' => $date]]);
638        if (!$s) {
639            $s = [];
640        }
641        $id = 0;
642        $sCount = count($s);
643        for ($i = 0; $i < $sCount; $i++) {
644            $id = $this->publishSingle($s[$i]['Schedule']['tsumego_id'], $s[$i]['Schedule']['set_id'], $s[$i]['Schedule']['date']);
645            $s[$i]['Schedule']['tsumego_id'] = $id;
646            $s[$i]['Schedule']['published'] = 1;
647            $this->Schedule->save($s[$i]);
648        }
649
650        return $id;
651    }
652
653    protected function publishSingle($t = null, $to = null, $date = null) {
654        $this->loadModel('Tsumego');
655        $this->loadModel('Sgf');
656        $this->loadModel('SetConnection');
657        $this->loadModel('PublishDate');
658        $ts = $this->Tsumego->findById($t);
659
660        $id = $this->Tsumego->find('first', ['limit' => 1, 'order' => 'id DESC']);
661        if (!$id) {
662            return null;
663        }
664        $id = $id['Tsumego']['id'];
665        $id += 1;
666
667        $scT = $this->SetConnection->find('first', ['conditions' => ['tsumego_id' => $ts['Tsumego']['id']]]);
668        if ($scT != null) {
669            $scT['SetConnection']['set_id'] = $to;
670            $scT['SetConnection']['tsumego_id'] = $id;
671            $scT['SetConnection']['num'] = $ts['Tsumego']['num'];
672            $this->SetConnection->save($scT);
673        } else {
674            $scT = [];
675            $scT['SetConnection']['set_id'] = $to;
676            $scT['SetConnection']['tsumego_id'] = $id;
677            $scT['SetConnection']['num'] = $ts['Tsumego']['num'];
678            $this->SetConnection->create();
679            $this->SetConnection->save($scT);
680        }
681
682        $sid = $ts['Tsumego']['id'];
683        $ts['Tsumego']['id'] = $id;
684        $ts['Tsumego']['created'] = $date . ' 22:00:00';
685        $ts['Tsumego']['solved'] = 0;
686        $ts['Tsumego']['failed'] = 0;
687        $ts['Tsumego']['userWin'] = 0;
688        $ts['Tsumego']['userLoss'] = 0;
689        $this->Tsumego->create();
690        $this->Tsumego->save($ts);
691        $this->Tsumego->delete($sid);
692
693        $sgfs = $this->Sgf->find('all', ['conditions' => ['tsumego_id' => $t]]);
694        if (!$sgfs) {
695            $sgfs = [];
696        }
697        $sgfsCount = count($sgfs);
698        for ($i = 0; $i < $sgfsCount; $i++) {
699            $sgfs[$i]['Sgf']['tsumego_id'] = $id;
700            $this->Sgf->save($sgfs[$i]);
701        }
702        $x = [];
703        $x['PublishDate']['date'] = $date . ' 22:00:00';
704        $x['PublishDate']['tsumego_id'] = $id;
705        $this->PublishDate->create();
706        $this->PublishDate->save($x);
707
708        return $id;
709    }
710
711    protected function getTsumegoOfTheDay() {
712        $this->loadModel('TsumegoAttempt');
713        $this->loadModel('TsumegoRatingAttempt');
714        $this->loadModel('Schedule');
715        $this->loadModel('Tsumego');
716        $this->loadModel('SetConnection');
717
718        $ut = $this->TsumegoRatingAttempt->find('all', ['limit' => 10000, 'order' => 'created DESC', 'conditions' => ['status' => 'S']]);
719        if (!$ut) {
720            $ut = [];
721        }
722        $out = $this->TsumegoAttempt->find('all', ['limit' => 30000, 'order' => 'created DESC', 'conditions' => ['gain >=' => 40]]);
723        if (!$out) {
724            $out = [];
725        }
726
727        $date = date('Y-m-d', strtotime('yesterday'));
728        $s = $this->Schedule->find('all', ['conditions' => ['date' => $date]]);
729        if (!$s) {
730            $s = [];
731        }
732        $ids = [];
733        $utCount = count($ut);
734        for ($i = 0; $i < $utCount; $i++) {
735            $date2 = new DateTime($ut[$i]['TsumegoRatingAttempt']['created']);
736            $date2 = $date2->format('Y-m-d');
737            if ($date === $date2) {
738                array_push($ids, $ut[$i]['TsumegoRatingAttempt']['tsumego_id']);
739            }
740        }
741        $ids = array_count_values($ids);
742        $highest = 0;
743        $best = [];
744        foreach ($ids as $key => $value) {
745            if ($value > $highest) {
746                $highest = $value;
747            }
748        }
749        foreach ($ids as $key => $value) {
750            if ($value == $highest) {
751                $x = [];
752                $x[$key] = $value;
753                array_push($best, $x);
754            }
755        }
756        $ids2 = [];
757        $out2 = [];
758        $outCount = count($out);
759        for ($i = 0; $i < $outCount; $i++) {
760            $date2 = new DateTime($out[$i]['TsumegoAttempt']['created']);
761            $date2 = $date2->format('Y-m-d');
762            if ($date === $date2) {
763                array_push($ids2, $out[$i]['TsumegoAttempt']['tsumego_id']);
764                array_push($out2, $out[$i]);
765            }
766        }
767        $ids2 = array_count_values($ids2);
768        $highest = 0;
769        $best2 = [];
770        foreach ($ids2 as $key => $value) {
771            if ($value > $highest) {
772                $highest = $value;
773            }
774        }
775        $done = false;
776        $found = 0;
777        $decrement = 0;
778        $best3 = [];
779        $findNum = 20;
780        while (!$done) {
781            foreach ($ids2 as $key => $value) {
782                if ($value == $highest - $decrement) {
783                    array_push($best2, $key);
784                    array_push($best3, $value);
785                    $found++;
786                }
787            }
788            $decrement++;
789            if ($found < $findNum) {
790                $done = false;
791            } else {
792                $done = true;
793            }
794        }
795        $newBest = [];
796        for ($j = 0; $j < $findNum; $j++) {
797            $newBest[$j] = [];
798        }
799        $out2Count = count($out2);
800        for ($i = 0; $i < $out2Count; $i++) {
801            for ($j = 0; $j < $findNum; $j++) {
802                if ($out2[$i]['TsumegoAttempt']['tsumego_id'] == $best2[$j]) {
803                    $x = [];
804                    $x['tid'] = $out2[$i]['TsumegoAttempt']['tsumego_id'];
805                    $tx = $this->Tsumego->findById($x['tid']);
806                    $scT = $this->SetConnection->find('first', ['conditions' => ['tsumego_id' => $tx['Tsumego']['id']]]);
807                    $tx['Tsumego']['set_id'] = $scT['SetConnection']['set_id'];
808                    $x['sid'] = $tx['Tsumego']['set_id'];
809                    $x['status'] = $out2[$i]['TsumegoAttempt']['solved'];
810                    $x['seconds'] = $out2[$i]['TsumegoAttempt']['seconds'];
811
812                    $newBest[$j][] = $x;
813                }
814            }
815        }
816        $newBestCount = count($newBest);
817        for ($i = 0; $i < $newBestCount; $i++) {
818            $sum = 0;
819            $newBestICount = count($newBest[$i]);
820            for ($j = 0; $j < $newBestICount; $j++) {
821                if ($newBest[$i][$j]['seconds'] != null) {
822                    if ($newBest[$i][$j]['seconds'] > 300) {
823                        $newBest[$i][$j]['seconds'] = 300;
824                    }
825                    $sum += $newBest[$i][$j]['seconds'];
826                }
827            }
828            $sum = $sum * count($newBest[$i]);
829            $newBest[$i]['sum'] = $sum;
830        }
831        $highest = 0;
832        $hid = 0;
833        $newBestCount = count($newBest);
834        for ($i = 0; $i < $newBestCount; $i++) {
835            if ($newBest[$i]['sum'] > $highest && $newBest[$i][0]['sid'] != 104 && $newBest[$i][0]['sid'] != 105 && $newBest[$i][0]['sid'] != 117) {
836                $yesterday = false;
837                $sCount = count($s);
838                for ($j = 0; $j < $sCount; $j++) {
839                    if ($newBest[$i][0]['tid'] == $s[$j]['Schedule']['tsumego_id']) {
840                        $yesterday = true;
841                    }
842                }
843                if (!$yesterday) {
844                    $highest = $newBest[$i]['sum'];
845                    $hid = $i;
846                }
847            }
848        }
849
850        return $newBest[$hid][0]['tid'];
851    }
852
853    protected function ratingMatch($elo) {
854        if ($elo >= 3000) {
855            $td = 10;//10d
856        } elseif ($elo >= 2900) {
857            $td = 10;//9d
858        } elseif ($elo >= 2800) {
859            $td = 10;//8d
860        } elseif ($elo >= 2700) {
861            $td = 10;//7d x2700
862        } elseif ($elo >= 2600) {
863            $td = 9;//6d x2600
864        } elseif ($elo >= 2500) {
865            $td = 8;//5d x2500
866        } elseif ($elo >= 2400) {
867            $td = 7;//4d
868        } elseif ($elo >= 2300) {
869            $td = 7;//3d x2350
870        } elseif ($elo >= 2200) {
871            $td = 6;//2d
872        } elseif ($elo >= 2100) {
873            $td = 6;//1d x2150
874        } elseif ($elo >= 2000) {
875            $td = 5;//1k
876        } elseif ($elo >= 1900) {
877            $td = 5;//2k x1950
878        } elseif ($elo >= 1800) {
879            $td = 4;//3k
880        } elseif ($elo >= 1700) {
881            $td = 4;//4k x1750
882        } elseif ($elo >= 1600) {
883            $td = 3;//5k
884        } elseif ($elo >= 1500) {
885            $td = 3;//6k x1500
886        } elseif ($elo >= 1400) {
887            $td = 3;//7k
888        } elseif ($elo >= 1300) {
889            $td = 2;//8k
890        } elseif ($elo >= 1200) {
891            $td = 2;//9k x1200
892        } elseif ($elo >= 1100) {
893            $td = 2;//10k
894        } elseif ($elo >= 1000) {
895            $td = 1;//11k
896        } elseif ($elo >= 900) {
897            $td = 1;//12k x900
898        } elseif ($elo >= 800) {
899            $td = 1;//13k
900        } elseif ($elo >= 700) {
901            $td = 1;//14k
902        } elseif ($elo >= 600) {
903            $td = 1;//15k
904        } elseif ($elo >= 500) {
905            $td = 1;//16k
906        } elseif ($elo >= 400) {
907            $td = 1;//17k
908        } elseif ($elo >= 300) {
909            $td = 1;//18k
910        } elseif ($elo >= 200) {
911            $td = 1;//19k
912        } elseif ($elo >= 100) {
913            $td = 1;//20k
914        } else {
915            $td = 1;
916        }
917
918        return $td;
919    }
920
921    protected function rating2($d) {
922        if ($d == 10) {
923            $elo = 2700;
924        } elseif ($d == 9) {
925            $elo = 2600;
926        } elseif ($d == 8) {
927            $elo = 2500;
928        } elseif ($d == 7) {
929            $elo = 2350;
930        } elseif ($d == 6) {
931            $elo = 2150;
932        } elseif ($d == 5) {
933            $elo = 1950;
934        } elseif ($d == 4) {
935            $elo = 1750;
936        } elseif ($d == 3) {
937            $elo = 1500;
938        } elseif ($d == 2) {
939            $elo = 1200;
940        } elseif ($d == 1) {
941            $elo = 900;
942        } else {
943            $elo = 1500;
944        }
945
946        return $elo;
947    }
948
949    public static function encrypt($str = null) {
950        $secret_key = 'my_simple_secret_keyx';
951        $secret_iv = 'my_simple_secret_ivx';
952        $encrypt_method = 'AES-256-CBC';
953        $key = hash('sha256', $secret_key);
954        $iv = substr(hash('sha256', $secret_iv), 0, 16);
955
956        return base64_encode(openssl_encrypt($str, $encrypt_method, $key, 0, $iv));
957    }
958
959    public static function decrypt($str = null) {
960        $string = $str;
961        $secret_key = 'my_simple_secret_keyx';
962        $secret_iv = 'my_simple_secret_ivx';
963        $encrypt_method = 'AES-256-CBC';
964        $key = hash('sha256', $secret_key);
965        $iv = substr(hash('sha256', $secret_iv), 0, 16);
966
967        return openssl_decrypt(base64_decode($string), $encrypt_method, $key, 0, $iv);
968    }
969
970    protected function checkPictureLarge($u) {
971        if (substr($u['User']['name'], 0, 3) == 'g__' && $u['User']['external_id'] != null) {
972            return '<img class="google-profile-image-large" src="/img/google/' . $u['User']['picture'] . '">' . substr($u['User']['name'], 3);
973        }
974
975        return $u['User']['name'];
976    }
977    public static function checkPicture($user) {
978        if (substr($user['name'], 0, 3) == 'g__' && $user['external_id'] != null) {
979            return '<img class="google-profile-image" src="/img/google/' . $user['picture'] . '">' . substr($user['name'], 3);
980        }
981
982        return $user['name'];
983    }
984
985    public static function getTsumegoRankx($t) {
986        if ($t <= 0) {
987            return '15k';
988        }
989        if ($t > 0 && $t <= 22) {
990            $tRank = '5d';
991        } elseif ($t <= 26.5) {
992            $tRank = '4d';
993        } elseif ($t <= 30) {
994            $tRank = '3d';
995        } elseif ($t <= 34) {
996            $tRank = '2d';
997        } elseif ($t <= 38) {
998            $tRank = '1d';
999        } elseif ($t <= 42) {
1000            $tRank = '1k';
1001        } elseif ($t <= 46) {
1002            $tRank = '2k';
1003        } elseif ($t <= 50) {
1004            $tRank = '3k';
1005        } elseif ($t <= 54.5) {
1006            $tRank = '4k';
1007        } elseif ($t <= 58.5) {
1008            $tRank = '5k';
1009        } elseif ($t <= 63) {
1010            $tRank = '6k';
1011        } elseif ($t <= 67) {
1012            $tRank = '7k';
1013        } elseif ($t <= 70.8) {
1014            $tRank = '8k';
1015        } elseif ($t <= 74.8) {
1016            $tRank = '9k';
1017        } elseif ($t <= 79) {
1018            $tRank = '10k';
1019        } elseif ($t <= 83.5) {
1020            $tRank = '11k';
1021        } elseif ($t <= 88) {
1022            $tRank = '12k';
1023        } elseif ($t <= 92) {
1024            $tRank = '13k';
1025        } elseif ($t <= 96) {
1026            $tRank = '14k';
1027        } else {
1028            $tRank = '15k';
1029        }
1030
1031        return $tRank;
1032    }
1033    protected function adjustElo($v) {
1034        $add = 0;
1035        if ($v >= 1700) {
1036            $add = 110;
1037        } elseif ($v >= 1600) {
1038            $add = 110;
1039        } elseif ($v >= 1700) {
1040            $add = 100;
1041        } elseif ($v >= 1600) {
1042            $add = 90;
1043        } elseif ($v >= 1500) {
1044            $add = 80;
1045        } elseif ($v >= 1400) {
1046            $add = 70;
1047        } elseif ($v >= 1300) {
1048            $add = 60;
1049        } elseif ($v >= 1200) {
1050            $add = 60;
1051        } elseif ($v >= 1100) {
1052            $add = 50;
1053        } elseif ($v >= 1000) {
1054            $add = 50;
1055        } else {
1056            $add = 0;
1057        }
1058
1059        return $v + $add;
1060    }
1061
1062    public static function getTsumegoElo($rank, $p = null) {
1063        if ($p != null) {
1064            $p *= 100;
1065        } else {
1066            $p = 0;
1067        }
1068        $elo = 600;
1069        if ($rank == '9d') {
1070            $elo = round(2900 + $p);
1071        } elseif ($rank == '8d') {
1072            $elo = round(2800 + $p);
1073        } elseif ($rank == '7d') {
1074            $elo = round(2700 + $p);
1075        } elseif ($rank == '6d') {
1076            $elo = round(2600 + $p);
1077        } elseif ($rank == '5d') {
1078            $elo = round(2500 + $p);
1079        } elseif ($rank == '4d') {
1080            $elo = round(2400 + $p);
1081        } elseif ($rank == '3d') {
1082            $elo = round(2300 + $p);
1083        } elseif ($rank == '2d') {
1084            $elo = round(2200 + $p);
1085        } elseif ($rank == '1d') {
1086            $elo = round(2100 + $p);
1087        } elseif ($rank == '1k') {
1088            $elo = round(2000 + $p);
1089        } elseif ($rank == '2k') {
1090            $elo = round(1900 + $p);
1091        } elseif ($rank == '3k') {
1092            $elo = round(1800 + $p);
1093        } elseif ($rank == '4k') {
1094            $elo = round(1700 + $p);
1095        } elseif ($rank == '5k') {
1096            $elo = round(1600 + $p);
1097        } elseif ($rank == '6k') {
1098            $elo = round(1500 + $p);
1099        } elseif ($rank == '7k') {
1100            $elo = round(1400 + $p);
1101        } elseif ($rank == '8k') {
1102            $elo = round(1300 + $p);
1103        } elseif ($rank == '9k') {
1104            $elo = round(1200 + $p);
1105        } elseif ($rank == '10k') {
1106            $elo = round(1100 + $p);
1107        } elseif ($rank == '11k') {
1108            $elo = round(1000 + $p);
1109        } elseif ($rank == '12k') {
1110            $elo = round(900 + $p);
1111        } elseif ($rank == '13k') {
1112            $elo = round(800 + $p);
1113        } elseif ($rank == '14k') {
1114            $elo = round(700 + $p);
1115        } elseif ($rank == '15k' || $rank == '16k' || $rank == '17k' || $rank == '18k' || $rank == '19k' || $rank == '20k' || $rank == '21k') {
1116            $elo = round(600 + $p);
1117        }
1118
1119        return $elo;
1120    }
1121    protected function getTsumegoRankVal($t) {
1122        if ($t <= 0) {
1123            return 0;
1124        }
1125        if ($t > 0 && $t <= 22) {
1126            return 22 - $t;
1127        }
1128        if ($t <= 26.5) {
1129            return 26.5 - $t;
1130        }
1131        if ($t <= 30) {
1132            return 30 - $t;
1133        }
1134        if ($t <= 34) {
1135            return 34 - $t;
1136        }
1137        if ($t <= 38) {
1138            return 38 - $t;
1139        }
1140        if ($t <= 42) {
1141            return 42 - $t;
1142        }
1143        if ($t <= 46) {
1144            return 46 - $t;
1145        }
1146        if ($t <= 50) {
1147            return 50 - $t;
1148        }
1149        if ($t <= 54.5) {
1150            return 54.5 - $t;
1151        }
1152        if ($t <= 58.5) {
1153            return 58.5 - $t;
1154        }
1155        if ($t <= 63) {
1156            return 63 - $t;
1157        }
1158        if ($t <= 67) {
1159            return 67 - $t;
1160        }
1161        if ($t <= 70.8) {
1162            return 70.8 - $t;
1163        }
1164        if ($t <= 74.8) {
1165            return 74.8 - $t;
1166        }
1167        if ($t <= 79) {
1168            return 79 - $t;
1169        }
1170        if ($t <= 83.5) {
1171            return 83.5 - $t;
1172        }
1173        if ($t <= 88) {
1174            return 88 - $t;
1175        }
1176        if ($t <= 92) {
1177            return 92 - $t;
1178        }
1179        if ($t <= 96) {
1180            return 96 - $t;
1181        }
1182
1183        return 100 - $t;
1184    }
1185    protected function getTsumegoRankMax($t) {
1186        if ($t <= 0) {
1187            return 100 - 96;
1188        }
1189        if ($t > 0 && $t <= 22) {
1190            return 22;
1191        }
1192        if ($t <= 26.5) {
1193            return 26.5 - 22;
1194        }
1195        if ($t <= 30) {
1196            return 30 - 26.5;
1197        }
1198        if ($t <= 34) {
1199            return 34 - 30;
1200        }
1201        if ($t <= 38) {
1202            return 38 - 34;
1203        }
1204        if ($t <= 42) {
1205            return 42 - 38;
1206        }
1207        if ($t <= 46) {
1208            return 46 - 42;
1209        }
1210        if ($t <= 50) {
1211            return 50 - 46;
1212        }
1213        if ($t <= 54.5) {
1214            return 54.5 - 50;
1215        }
1216        if ($t <= 58.5) {
1217            return 58.5 - 54.5;
1218        }
1219        if ($t <= 63) {
1220            return 63 - 58.5;
1221        }
1222        if ($t <= 67) {
1223            return 67 - 63;
1224        }
1225        if ($t <= 70.8) {
1226            return 70.8 - 67;
1227        }
1228        if ($t <= 74.8) {
1229            return 74.8 - 70.8;
1230        }
1231        if ($t <= 79) {
1232            return 79 - 74.8;
1233        }
1234        if ($t <= 83.5) {
1235            return 83.5 - 79;
1236        }
1237        if ($t <= 88) {
1238            return 88 - 83.5;
1239        }
1240        if ($t <= 92) {
1241            return 92 - 88;
1242        }
1243        if ($t <= 96) {
1244            return 96 - 92;
1245        }
1246
1247        return 100 - 96;
1248    }
1249
1250    public static function saveDanSolveCondition($solvedTsumegoRank, $tId): void {
1251        if ($solvedTsumegoRank == '1d' || $solvedTsumegoRank == '2d' || $solvedTsumegoRank == '3d' || $solvedTsumegoRank == '4d' || $solvedTsumegoRank == '5d') {
1252            $danSolveCategory = 'danSolve' . $solvedTsumegoRank;
1253            $danSolveCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1254                'order' => 'value DESC',
1255                'conditions' => [
1256                    'user_id' => Auth::getUserID(),
1257                    'category' => $danSolveCategory,
1258                ],
1259            ]);
1260            if (!$danSolveCondition) {
1261                $danSolveCondition = [];
1262                $danSolveCondition['AchievementCondition']['value'] = 0;
1263                ClassRegistry::init('AchievementCondition')->create();
1264            }
1265            $danSolveCondition['AchievementCondition']['category'] = $danSolveCategory;
1266            $danSolveCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1267            $danSolveCondition['AchievementCondition']['set_id'] = $tId;
1268            $danSolveCondition['AchievementCondition']['value']++;
1269
1270            ClassRegistry::init('AchievementCondition')->save($danSolveCondition);
1271        }
1272    }
1273
1274    public static function updateSprintCondition(bool $trigger = false): void {
1275        if (Auth::isLoggedIn()) {
1276            $sprintCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1277                'order' => 'value DESC',
1278                'conditions' => [
1279                    'user_id' => Auth::getUserID(),
1280                    'category' => 'sprint',
1281                ],
1282            ]);
1283            if (!$sprintCondition) {
1284                $sprintCondition = [];
1285                $sprintCondition['AchievementCondition']['value'] = 0;
1286                ClassRegistry::init('AchievementCondition')->create();
1287            }
1288            $sprintCondition['AchievementCondition']['category'] = 'sprint';
1289            $sprintCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1290            if ($trigger) {
1291                $sprintCondition['AchievementCondition']['value']++;
1292            } else {
1293                $sprintCondition['AchievementCondition']['value'] = 0;
1294            }
1295            ClassRegistry::init('AchievementCondition')->save($sprintCondition);
1296        }
1297    }
1298
1299    public static function updateGoldenCondition(bool $trigger = false): void {
1300        $goldenCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1301            'order' => 'value DESC',
1302            'conditions' => [
1303                'user_id' => Auth::getUserID(),
1304                'category' => 'golden',
1305            ],
1306        ]);
1307        if (!$goldenCondition) {
1308            $goldenCondition = [];
1309            $goldenCondition['AchievementCondition']['value'] = 0;
1310            ClassRegistry::init('AchievementCondition')->create();
1311        }
1312        $goldenCondition['AchievementCondition']['category'] = 'golden';
1313        $goldenCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1314        if ($trigger) {
1315            $goldenCondition['AchievementCondition']['value']++;
1316        } else {
1317            $goldenCondition['AchievementCondition']['value'] = 0;
1318        }
1319        ClassRegistry::init('AchievementCondition')->save($goldenCondition);
1320    }
1321
1322    public static function setPotionCondition(): void {
1323        $potionCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1324            'order' => 'value DESC',
1325            'conditions' => [
1326                'user_id' => Auth::getUserID(),
1327                'category' => 'potion',
1328            ],
1329        ]);
1330        if (!$potionCondition) {
1331            $potionCondition = [];
1332            ClassRegistry::init('AchievementCondition')->create();
1333        }
1334        $potionCondition['AchievementCondition']['category'] = 'potion';
1335        $potionCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1336        $potionCondition['AchievementCondition']['value'] = 1;
1337        ClassRegistry::init('AchievementCondition')->save($potionCondition);
1338    }
1339
1340    public static function updateGems(string $rank): void {
1341        $datex = new DateTime('today');
1342        $dateGem = ClassRegistry::init('DayRecord')->find('first', ['conditions' => ['date' => $datex->format('Y-m-d')]]);
1343        if ($dateGem != null) {
1344            $gems = explode('-', $dateGem['DayRecord']['gems']);
1345            $gemValue = '';
1346            $gemValue2 = '';
1347            $gemValue3 = '';
1348            $condition1 = 500;
1349            $condition2 = 200;
1350            $condition3 = 5;
1351            $found1 = false;
1352            $found2 = false;
1353            $found3 = false;
1354            if ($rank == '15k' || $rank == '14k' || $rank == '13k' || $rank == '12k' || $rank == '11k' || $rank == '10k') {
1355                if ($gems[0] == 0) {
1356                    $gemValue = '15k';
1357                } elseif ($gems[0] == 1) {
1358                    $gemValue = '12k';
1359                } elseif ($gems[0] == 2) {
1360                    $gemValue = '10k';
1361                }
1362                if ($rank == $gemValue) {
1363                    $dateGem['DayRecord']['gemCounter1']++;
1364                    if ($dateGem['DayRecord']['gemCounter1'] == $condition1) {
1365                        $found1 = true;
1366                    }
1367                }
1368            } elseif ($rank == '9k' || $rank == '8k' || $rank == '7k' || $rank == '6k' || $rank == '5k' || $rank == '4k' || $rank == '3k' || $rank == '2k' || $rank == '1k') {
1369                if ($gems[1] == 0) {
1370                    $gemValue = '9k';
1371                    $gemValue2 = 'x';
1372                    $gemValue3 = 'y';
1373                } elseif ($gems[1] == 1) {
1374                    $gemValue = '6k';
1375                    $gemValue2 = '5k';
1376                    $gemValue3 = '4k';
1377                } elseif ($gems[1] == 2) {
1378                    $gemValue = 'x';
1379                    $gemValue2 = '2k';
1380                    $gemValue3 = '1k';
1381                }
1382                if ($rank == $gemValue || $rank == $gemValue2 || $rank == $gemValue3) {
1383                    $dateGem['DayRecord']['gemCounter2']++;
1384                    if ($dateGem['DayRecord']['gemCounter2'] == $condition2) {
1385                        $found2 = true;
1386                    }
1387                }
1388            } elseif ($rank == '1d' || $rank == '2d' || $rank == '3d' || $rank == '4d' || $rank == '5d' || $rank == '6d' || $rank == '7d') {
1389                if ($gems[2] == 0) {
1390                    $gemValue = '1d';
1391                    $gemValue2 = '2d';
1392                    $gemValue3 = '3d';
1393                } elseif ($gems[2] == 1) {
1394                    $gemValue = '2d';
1395                    $gemValue2 = '3d';
1396                    $gemValue3 = '4d';
1397                } elseif ($gems[2] == 2) {
1398                    $gemValue = '5d';
1399                    $gemValue2 = '6d';
1400                    $gemValue3 = '7d';
1401                }
1402                if ($rank == $gemValue || $rank == $gemValue2 || $rank == $gemValue3) {
1403                    $dateGem['DayRecord']['gemCounter3']++;
1404                    if ($dateGem['DayRecord']['gemCounter3'] == $condition3) {
1405                        $found3 = true;
1406                    }
1407                }
1408            }
1409            if ($found1) {
1410                $aCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1411                    'order' => 'value DESC',
1412                    'conditions' => [
1413                        'user_id' => Auth::getUserID(),
1414                        'category' => 'emerald',
1415                    ],
1416                ]);
1417                if ($aCondition == null) {
1418                    $aCondition = [];
1419                    $aCondition['AchievementCondition']['category'] = 'emerald';
1420                    $aCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1421                    $aCondition['AchievementCondition']['value'] = 1;
1422                    ClassRegistry::init('AchievementCondition')->save($aCondition);
1423                } else {
1424                    $dateGem['DayRecord']['gemCounter1']--;
1425                }
1426            } elseif ($found2) {
1427                $aCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1428                    'order' => 'value DESC',
1429                    'conditions' => [
1430                        'user_id' => Auth::getUserID(),
1431                        'category' => 'sapphire',
1432                    ],
1433                ]);
1434                if ($aCondition == null) {
1435                    $aCondition = [];
1436                    $aCondition['AchievementCondition']['category'] = 'sapphire';
1437                    $aCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1438                    $aCondition['AchievementCondition']['value'] = 1;
1439                    ClassRegistry::init('AchievementCondition')->save($aCondition);
1440                } else {
1441                    $dateGem['DayRecord']['gemCounter2']--;
1442                }
1443            } elseif ($found3) {
1444                $aCondition = ClassRegistry::init('AchievementCondition')->find('first', [
1445                    'order' => 'value DESC',
1446                    'conditions' => [
1447                        'user_id' => Auth::getUserID(),
1448                        'category' => 'ruby',
1449                    ],
1450                ]);
1451                if ($aCondition == null) {
1452                    $aCondition = [];
1453                    $aCondition['AchievementCondition']['category'] = 'ruby';
1454                    $aCondition['AchievementCondition']['user_id'] = Auth::getUserID();
1455                    $aCondition['AchievementCondition']['value'] = 1;
1456                    ClassRegistry::init('AchievementCondition')->save($aCondition);
1457                } else {
1458                    $dateGem['DayRecord']['gemCounter3']--;
1459                }
1460            }
1461        }
1462        ClassRegistry::init('DayRecord')->save($dateGem);
1463    }
1464
1465    public static function checkProblemNumberAchievements() {
1466        if (!Auth::isLoggedIn()) {
1467            return;
1468        }
1469
1470        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
1471        if (!$buffer) {
1472            $buffer = [];
1473        }
1474        $existingAs = [];
1475        $bufferCount = count($buffer);
1476        for ($i = 0; $i < $bufferCount; $i++) {
1477            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
1478        }
1479        $as = [];
1480        $as['AchievementStatus']['user_id'] = Auth::getUserID();
1481        $updated = [];
1482
1483        $achievementId = 1;
1484        $solvedCount = Auth::getUser()['solved'];
1485        if ($solvedCount >= 1000 && !isset($existingAs[$achievementId])) {
1486            $as['AchievementStatus']['achievement_id'] = $achievementId;
1487            ClassRegistry::init('AchievementStatus')->create();
1488            ClassRegistry::init('AchievementStatus')->save($as);
1489            array_push($updated, $achievementId);
1490        }
1491        $achievementId = 2;
1492        if ($solvedCount >= 2000 && !isset($existingAs[$achievementId])) {
1493            $as['AchievementStatus']['achievement_id'] = $achievementId;
1494            ClassRegistry::init('AchievementStatus')->create();
1495            ClassRegistry::init('AchievementStatus')->save($as);
1496            array_push($updated, $achievementId);
1497        }
1498        $achievementId = 3;
1499        if ($solvedCount >= 3000 && !isset($existingAs[$achievementId])) {
1500            $as['AchievementStatus']['achievement_id'] = $achievementId;
1501            ClassRegistry::init('AchievementStatus')->create();
1502            ClassRegistry::init('AchievementStatus')->save($as);
1503            array_push($updated, $achievementId);
1504        }
1505        $achievementId = 4;
1506        if ($solvedCount >= 4000 && !isset($existingAs[$achievementId])) {
1507            $as['AchievementStatus']['achievement_id'] = $achievementId;
1508            ClassRegistry::init('AchievementStatus')->create();
1509            ClassRegistry::init('AchievementStatus')->save($as);
1510            array_push($updated, $achievementId);
1511        }
1512        $achievementId = 5;
1513        if ($solvedCount >= 5000 && !isset($existingAs[$achievementId])) {
1514            $as['AchievementStatus']['achievement_id'] = $achievementId;
1515            ClassRegistry::init('AchievementStatus')->create();
1516            ClassRegistry::init('AchievementStatus')->save($as);
1517            array_push($updated, $achievementId);
1518        }
1519        $achievementId = 6;
1520        if ($solvedCount >= 6000 && !isset($existingAs[$achievementId])) {
1521            $as['AchievementStatus']['achievement_id'] = $achievementId;
1522            ClassRegistry::init('AchievementStatus')->create();
1523            ClassRegistry::init('AchievementStatus')->save($as);
1524            array_push($updated, $achievementId);
1525        }
1526        $achievementId = 7;
1527        if ($solvedCount >= 7000 && !isset($existingAs[$achievementId])) {
1528            $as['AchievementStatus']['achievement_id'] = $achievementId;
1529            ClassRegistry::init('AchievementStatus')->create();
1530            ClassRegistry::init('AchievementStatus')->save($as);
1531            array_push($updated, $achievementId);
1532        }
1533        $achievementId = 8;
1534        if ($solvedCount >= 8000 && !isset($existingAs[$achievementId])) {
1535            $as['AchievementStatus']['achievement_id'] = $achievementId;
1536            ClassRegistry::init('AchievementStatus')->create();
1537            ClassRegistry::init('AchievementStatus')->save($as);
1538            array_push($updated, $achievementId);
1539        }
1540        $achievementId = 9;
1541        if ($solvedCount >= 9000 && !isset($existingAs[$achievementId])) {
1542            $as['AchievementStatus']['achievement_id'] = $achievementId;
1543            ClassRegistry::init('AchievementStatus')->create();
1544            ClassRegistry::init('AchievementStatus')->save($as);
1545            array_push($updated, $achievementId);
1546        }
1547        $achievementId = 10;
1548        if ($solvedCount >= 10000 && !isset($existingAs[$achievementId])) {
1549            $as['AchievementStatus']['achievement_id'] = $achievementId;
1550            ClassRegistry::init('AchievementStatus')->create();
1551            ClassRegistry::init('AchievementStatus')->save($as);
1552            array_push($updated, $achievementId);
1553        }
1554        //uotd achievement
1555        $achievementId = 11;
1556        if (!isset($existingAs[$achievementId])) {
1557            $condition = ClassRegistry::init('AchievementCondition')->find('first', ['conditions' => ['user_id' => Auth::getUserID(), 'category' => 'uotd']]);
1558            if ($condition != null) {
1559                $as['AchievementStatus']['achievement_id'] = $achievementId;
1560                ClassRegistry::init('AchievementStatus')->create();
1561                ClassRegistry::init('AchievementStatus')->save($as);
1562                array_push($updated, $achievementId);
1563            }
1564        }
1565
1566        $updatedCount = count($updated);
1567        for ($i = 0; $i < $updatedCount; $i++) {
1568            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
1569            $updated[$i] = [];
1570            $updated[$i][0] = $a['Achievement']['name'];
1571            $updated[$i][1] = $a['Achievement']['description'];
1572            $updated[$i][2] = $a['Achievement']['image'];
1573            $updated[$i][3] = $a['Achievement']['color'];
1574            $updated[$i][4] = $a['Achievement']['xp'];
1575            $updated[$i][5] = $a['Achievement']['id'];
1576        }
1577
1578        return $updated;
1579    }
1580
1581    public static function checkDanSolveAchievements() {
1582        if (Auth::isLoggedIn()) {
1583            $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
1584            if (!$buffer) {
1585                $buffer = [];
1586            }
1587            $ac = ClassRegistry::init('AchievementCondition')->find('all', [
1588                'order' => 'category ASC',
1589                'conditions' => [
1590                    'user_id' => Auth::getUserID(),
1591                    'OR' => [
1592                        ['category' => 'danSolve1d'],
1593                        ['category' => 'danSolve2d'],
1594                        ['category' => 'danSolve3d'],
1595                        ['category' => 'danSolve4d'],
1596                        ['category' => 'danSolve5d'],
1597                        ['category' => 'emerald'],
1598                        ['category' => 'sapphire'],
1599                        ['category' => 'ruby'],
1600                        ['category' => 'sprint'],
1601                        ['category' => 'golden'],
1602                        ['category' => 'potion'],
1603                    ],
1604                ],
1605            ]);
1606            if (!$ac) {
1607                $ac = [];
1608            }
1609            $ac1 = [];
1610            $acCount = count($ac);
1611            for ($i = 0; $i < $acCount; $i++) {
1612                if ($ac[$i]['AchievementCondition']['category'] == 'danSolve1d') {
1613                    $ac1['1d'] = $ac[$i]['AchievementCondition']['value'];
1614                } elseif ($ac[$i]['AchievementCondition']['category'] == 'danSolve2d') {
1615                    $ac1['2d'] = $ac[$i]['AchievementCondition']['value'];
1616                } elseif ($ac[$i]['AchievementCondition']['category'] == 'danSolve3d') {
1617                    $ac1['3d'] = $ac[$i]['AchievementCondition']['value'];
1618                } elseif ($ac[$i]['AchievementCondition']['category'] == 'danSolve4d') {
1619                    $ac1['4d'] = $ac[$i]['AchievementCondition']['value'];
1620                } elseif ($ac[$i]['AchievementCondition']['category'] == 'danSolve5d') {
1621                    $ac1['5d'] = $ac[$i]['AchievementCondition']['value'];
1622                } elseif ($ac[$i]['AchievementCondition']['category'] == 'emerald') {
1623                    $ac1['emerald'] = $ac[$i]['AchievementCondition']['value'];
1624                } elseif ($ac[$i]['AchievementCondition']['category'] == 'sapphire') {
1625                    $ac1['sapphire'] = $ac[$i]['AchievementCondition']['value'];
1626                } elseif ($ac[$i]['AchievementCondition']['category'] == 'ruby') {
1627                    $ac1['ruby'] = $ac[$i]['AchievementCondition']['value'];
1628                } elseif ($ac[$i]['AchievementCondition']['category'] == 'sprint') {
1629                    $ac1['sprint'] = $ac[$i]['AchievementCondition']['value'];
1630                } elseif ($ac[$i]['AchievementCondition']['category'] == 'golden') {
1631                    $ac1['golden'] = $ac[$i]['AchievementCondition']['value'];
1632                } elseif ($ac[$i]['AchievementCondition']['category'] == 'potion') {
1633                    $ac1['potion'] = $ac[$i]['AchievementCondition']['value'];
1634                }
1635            }
1636
1637            $existingAs = [];
1638            $bufferCount = count($buffer);
1639            for ($i = 0; $i < $bufferCount; $i++) {
1640                $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
1641            }
1642            $as = [];
1643            $as['AchievementStatus']['user_id'] = Auth::getUserID();
1644            $updated = [];
1645            $achievementId = 101;
1646            if ($ac1['1d'] > 0 && !isset($existingAs[$achievementId])) {
1647                $as['AchievementStatus']['achievement_id'] = $achievementId;
1648                ClassRegistry::init('AchievementStatus')->create();
1649                ClassRegistry::init('AchievementStatus')->save($as);
1650                array_push($updated, $achievementId);
1651            }
1652            $achievementId = 102;
1653            if ($ac1['2d'] > 0 && !isset($existingAs[$achievementId])) {
1654                $as['AchievementStatus']['achievement_id'] = $achievementId;
1655                ClassRegistry::init('AchievementStatus')->create();
1656                ClassRegistry::init('AchievementStatus')->save($as);
1657                array_push($updated, $achievementId);
1658            }
1659            $achievementId = 103;
1660            if ($ac1['3d'] > 0 && !isset($existingAs[$achievementId])) {
1661                $as['AchievementStatus']['achievement_id'] = $achievementId;
1662                ClassRegistry::init('AchievementStatus')->create();
1663                ClassRegistry::init('AchievementStatus')->save($as);
1664                array_push($updated, $achievementId);
1665            }
1666            $achievementId = 104;
1667            if ($ac1['4d'] > 0 && !isset($existingAs[$achievementId])) {
1668                $as['AchievementStatus']['achievement_id'] = $achievementId;
1669                ClassRegistry::init('AchievementStatus')->create();
1670                ClassRegistry::init('AchievementStatus')->save($as);
1671                array_push($updated, $achievementId);
1672            }
1673            $achievementId = 105;
1674            if ($ac1['5d'] > 0 && !isset($existingAs[$achievementId])) {
1675                $as['AchievementStatus']['achievement_id'] = $achievementId;
1676                ClassRegistry::init('AchievementStatus')->create();
1677                ClassRegistry::init('AchievementStatus')->save($as);
1678                array_push($updated, $achievementId);
1679            }
1680            $achievementId = 106;
1681            if ($ac1['1d'] >= 10 && !isset($existingAs[$achievementId])) {
1682                $as['AchievementStatus']['achievement_id'] = $achievementId;
1683                ClassRegistry::init('AchievementStatus')->create();
1684                ClassRegistry::init('AchievementStatus')->save($as);
1685                array_push($updated, $achievementId);
1686            }
1687            $achievementId = 107;
1688            if ($ac1['2d'] >= 10 && !isset($existingAs[$achievementId])) {
1689                $as['AchievementStatus']['achievement_id'] = $achievementId;
1690                ClassRegistry::init('AchievementStatus')->create();
1691                ClassRegistry::init('AchievementStatus')->save($as);
1692                array_push($updated, $achievementId);
1693            }
1694            $achievementId = 108;
1695            if ($ac1['3d'] >= 10 && !isset($existingAs[$achievementId])) {
1696                $as['AchievementStatus']['achievement_id'] = $achievementId;
1697                ClassRegistry::init('AchievementStatus')->create();
1698                ClassRegistry::init('AchievementStatus')->save($as);
1699                array_push($updated, $achievementId);
1700            }
1701            $achievementId = 109;
1702            if ($ac1['4d'] >= 10 && !isset($existingAs[$achievementId])) {
1703                $as['AchievementStatus']['achievement_id'] = $achievementId;
1704                ClassRegistry::init('AchievementStatus')->create();
1705                ClassRegistry::init('AchievementStatus')->save($as);
1706                array_push($updated, $achievementId);
1707            }
1708            $achievementId = 110;
1709            if ($ac1['5d'] >= 10 && !isset($existingAs[$achievementId])) {
1710                $as['AchievementStatus']['achievement_id'] = $achievementId;
1711                ClassRegistry::init('AchievementStatus')->create();
1712                ClassRegistry::init('AchievementStatus')->save($as);
1713                array_push($updated, $achievementId);
1714            }
1715            $achievementId = 111;
1716            if (isset($ac1['emerald'])) {
1717                if ($ac1['emerald'] == 1 && !isset($existingAs[$achievementId])) {
1718                    $as['AchievementStatus']['achievement_id'] = $achievementId;
1719                    ClassRegistry::init('AchievementStatus')->create();
1720                    ClassRegistry::init('AchievementStatus')->save($as);
1721                    array_push($updated, $achievementId);
1722                }
1723            }
1724            $achievementId = 112;
1725            if (isset($ac1['sapphire'])) {
1726                if ($ac1['sapphire'] == 1 && !isset($existingAs[$achievementId])) {
1727                    $as['AchievementStatus']['achievement_id'] = $achievementId;
1728                    ClassRegistry::init('AchievementStatus')->create();
1729                    ClassRegistry::init('AchievementStatus')->save($as);
1730                    array_push($updated, $achievementId);
1731                }
1732            }
1733            $achievementId = 113;
1734            if (isset($ac1['ruby'])) {
1735                if ($ac1['ruby'] == 1 && !isset($existingAs[$achievementId])) {
1736                    $as['AchievementStatus']['achievement_id'] = $achievementId;
1737                    ClassRegistry::init('AchievementStatus')->create();
1738                    ClassRegistry::init('AchievementStatus')->save($as);
1739                    array_push($updated, $achievementId);
1740                }
1741            }
1742            $achievementId = 114;
1743            if (!isset($existingAs[$achievementId]) && isset($existingAs[111]) && isset($existingAs[112]) && isset($existingAs[113])) {
1744                $as['AchievementStatus']['achievement_id'] = $achievementId;
1745                ClassRegistry::init('AchievementStatus')->create();
1746                ClassRegistry::init('AchievementStatus')->save($as);
1747                array_push($updated, $achievementId);
1748            }
1749            $achievementId = 96;
1750            if (!isset($existingAs[$achievementId]) && $ac1['sprint'] >= 30) {
1751                $as['AchievementStatus']['achievement_id'] = $achievementId;
1752                ClassRegistry::init('AchievementStatus')->create();
1753                ClassRegistry::init('AchievementStatus')->save($as);
1754                array_push($updated, $achievementId);
1755            }
1756            $achievementId = 97;
1757            if (!isset($existingAs[$achievementId]) && $ac1['golden'] >= 10) {
1758                $as['AchievementStatus']['achievement_id'] = $achievementId;
1759                ClassRegistry::init('AchievementStatus')->create();
1760                ClassRegistry::init('AchievementStatus')->save($as);
1761                array_push($updated, $achievementId);
1762            }
1763            $achievementId = 98;
1764            if (!isset($existingAs[$achievementId]) && $ac1['potion'] >= 1) {
1765                $as['AchievementStatus']['achievement_id'] = $achievementId;
1766                ClassRegistry::init('AchievementStatus')->create();
1767                ClassRegistry::init('AchievementStatus')->save($as);
1768                array_push($updated, $achievementId);
1769            }
1770            $updatedCount = count($updated);
1771            for ($i = 0; $i < $updatedCount; $i++) {
1772                $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
1773                $updated[$i] = [];
1774                $updated[$i][0] = $a['Achievement']['name'];
1775                $updated[$i][1] = $a['Achievement']['description'];
1776                $updated[$i][2] = $a['Achievement']['image'];
1777                $updated[$i][3] = $a['Achievement']['color'];
1778                $updated[$i][4] = $a['Achievement']['xp'];
1779                $updated[$i][5] = $a['Achievement']['id'];
1780            }
1781
1782            return $updated;
1783        }
1784    }
1785
1786    protected function checkForLocked($t, $setsWithPremium) {
1787        $scCheck = $this->SetConnection->find('first', ['conditions' => ['tsumego_id' => $t['Tsumego']['id']]]);
1788        if ($scCheck && in_array($scCheck['SetConnection']['set_id'], $setsWithPremium) && !Auth::hasPremium()) {
1789            $t['Tsumego']['locked'] = true;
1790        } else {
1791            $t['Tsumego']['locked'] = false;
1792        }
1793
1794        return $t;
1795    }
1796    public static function checkNoErrorAchievements() {
1797        if (Auth::isLoggedIn()) {
1798
1799            $ac = ClassRegistry::init('AchievementCondition')->find('first', [
1800                'order' => 'value DESC',
1801                'conditions' => [
1802                    'user_id' => Auth::getUserID(),
1803                    'category' => 'err',
1804                ],
1805            ]);
1806
1807            $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
1808            if (!$buffer) {
1809                $buffer = [];
1810            }
1811            $existingAs = [];
1812            $bufferCount = count($buffer);
1813            for ($i = 0; $i < $bufferCount; $i++) {
1814                $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
1815            }
1816            $as = [];
1817            $as['AchievementStatus']['user_id'] = Auth::getUserID();
1818            $updated = [];
1819
1820            $achievementId = 53;
1821            if ($ac['AchievementCondition']['value'] >= 10 && !isset($existingAs[$achievementId])) {
1822                $as['AchievementStatus']['achievement_id'] = $achievementId;
1823                ClassRegistry::init('AchievementStatus')->create();
1824                ClassRegistry::init('AchievementStatus')->save($as);
1825                array_push($updated, $achievementId);
1826            }
1827            $achievementId = 54;
1828            if ($ac['AchievementCondition']['value'] >= 20 && !isset($existingAs[$achievementId])) {
1829                $as['AchievementStatus']['achievement_id'] = $achievementId;
1830                ClassRegistry::init('AchievementStatus')->create();
1831                ClassRegistry::init('AchievementStatus')->save($as);
1832                array_push($updated, $achievementId);
1833            }
1834            $achievementId = 55;
1835            if ($ac['AchievementCondition']['value'] >= 30 && !isset($existingAs[$achievementId])) {
1836                $as['AchievementStatus']['achievement_id'] = $achievementId;
1837                ClassRegistry::init('AchievementStatus')->create();
1838                ClassRegistry::init('AchievementStatus')->save($as);
1839                array_push($updated, $achievementId);
1840            }
1841            $achievementId = 56;
1842            if ($ac['AchievementCondition']['value'] >= 50 && !isset($existingAs[$achievementId])) {
1843                $as['AchievementStatus']['achievement_id'] = $achievementId;
1844                ClassRegistry::init('AchievementStatus')->create();
1845                ClassRegistry::init('AchievementStatus')->save($as);
1846                array_push($updated, $achievementId);
1847            }
1848            $achievementId = 57;
1849            if ($ac['AchievementCondition']['value'] >= 100 && !isset($existingAs[$achievementId])) {
1850                $as['AchievementStatus']['achievement_id'] = $achievementId;
1851                ClassRegistry::init('AchievementStatus')->create();
1852                ClassRegistry::init('AchievementStatus')->save($as);
1853                array_push($updated, $achievementId);
1854            }
1855            $achievementId = 58;
1856            if ($ac['AchievementCondition']['value'] >= 200 && !isset($existingAs[$achievementId])) {
1857                $as['AchievementStatus']['achievement_id'] = $achievementId;
1858                ClassRegistry::init('AchievementStatus')->create();
1859                ClassRegistry::init('AchievementStatus')->save($as);
1860                array_push($updated, $achievementId);
1861            }
1862            $updatedCount = count($updated);
1863            for ($i = 0; $i < $updatedCount; $i++) {
1864                $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
1865                $updated[$i] = [];
1866                $updated[$i][0] = $a['Achievement']['name'];
1867                $updated[$i][1] = $a['Achievement']['description'];
1868                $updated[$i][2] = $a['Achievement']['image'];
1869                $updated[$i][3] = $a['Achievement']['color'];
1870                $updated[$i][4] = $a['Achievement']['xp'];
1871                $updated[$i][5] = $a['Achievement']['id'];
1872            }
1873
1874            return $updated;
1875        }
1876    }
1877
1878    protected function checkTimeModeAchievements() {
1879        $this->loadModel('Achievement');
1880        $this->loadModel('AchievementStatus');
1881        $this->loadModel('TimeModeSession');
1882
1883        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
1884        if (!$buffer) {
1885            $buffer = [];
1886        }
1887        $existingAs = [];
1888        $bufferCount = count($buffer);
1889        for ($i = 0; $i < $bufferCount; $i++) {
1890            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
1891        }
1892        $as = [];
1893        $as['AchievementStatus']['user_id'] = Auth::getUserID();
1894        $updated = [];
1895
1896        $rBlitz = $this->TimeModeSession->find('all', ['conditions' => ['time_mode_category_id' => TimeModeUtil::$CATEGORY_BLITZ, 'user_id' => Auth::getUserID()]]);
1897        if (!$rBlitz) {
1898            $rBlitz = [];
1899        }
1900        $rFast = $this->TimeModeSession->find('all', ['conditions' => ['time_mode_category_id' => TimeModeUtil::$CATEGORY_FAST_SPEED, 'user_id' => Auth::getUserID()]]);
1901        if (!$rFast) {
1902            $rFast = [];
1903        }
1904        $rSlow = $this->TimeModeSession->find('all', ['conditions' => ['time_mode_category_id' => TimeModeUtil::$CATEGORY_SLOW_SPEED, 'user_id' => Auth::getUserID()]]);
1905        if (!$rSlow) {
1906            $rSlow = [];
1907        }
1908        $r = $this->TimeModeSession->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
1909        if (!$r) {
1910            $r = [];
1911        }
1912
1913        $timeModeAchievements = [];
1914        for ($i = 70; $i <= 91; $i++) {
1915            $timeModeAchievements[$i] = false;
1916        }
1917        $rCount = count($r);
1918        for ($i = 0; $i < $rCount; $i++) {
1919            if ($r[$i]['TimeModeSession']['status'] == 's') {
1920                if ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '5k') {
1921                    if ($r[$i]['TimeModeSession']['mode'] == 2) {
1922                        $timeModeAchievements[70] = true;
1923                    } elseif ($r[$i]['TimeModeSession']['mode'] == 1) {
1924                        $timeModeAchievements[76] = true;
1925                    } elseif ($r[$i]['TimeModeSession']['mode'] == 0) {
1926                        $timeModeAchievements[82] = true;
1927                    }
1928                } elseif ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '4k') {
1929                    if ($r[$i]['TimeModeSession']['mode'] == 2) {
1930                        $timeModeAchievements[71] = true;
1931                    } elseif ($r[$i]['TimeModeSession']['mode'] == 1) {
1932                        $timeModeAchievements[77] = true;
1933                    } elseif ($r[$i]['TimeModeSession']['mode'] == 0) {
1934                        $timeModeAchievements[83] = true;
1935                    }
1936                } elseif ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '3k') {
1937                    if ($r[$i]['TimeModeSession']['mode'] == 2) {
1938                        $timeModeAchievements[72] = true;
1939                    } elseif ($r[$i]['TimeModeSession']['mode'] == 1) {
1940                        $timeModeAchievements[78] = true;
1941                    } elseif ($r[$i]['TimeModeSession']['mode'] == 0) {
1942                        $timeModeAchievements[84] = true;
1943                    }
1944                } elseif ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '2k') {
1945                    if ($r[$i]['TimeModeSession']['mode'] == 2) {
1946                        $timeModeAchievements[73] = true;
1947                    } elseif ($r[$i]['TimeModeSession']['mode'] == 1) {
1948                        $timeModeAchievements[79] = true;
1949                    } elseif ($r[$i]['TimeModeSession']['mode'] == 0) {
1950                        $timeModeAchievements[85] = true;
1951                    }
1952                } elseif ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '1k') {
1953                    if ($r[$i]['TimeModeSession']['mode'] == 2) {
1954                        $timeModeAchievements[74] = true;
1955                    } elseif ($r[$i]['TimeModeSession']['mode'] == 1) {
1956                        $timeModeAchievements[80] = true;
1957                    } elseif ($r[$i]['TimeModeSession']['mode'] == 0) {
1958                        $timeModeAchievements[86] = true;
1959                    }
1960                } elseif ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '1d') {
1961                    if ($r[$i]['TimeModeSession']['mode'] == 2) {
1962                        $timeModeAchievements[75] = true;
1963                    } elseif ($r[$i]['TimeModeSession']['mode'] == 1) {
1964                        $timeModeAchievements[81] = true;
1965                    } elseif ($r[$i]['TimeModeSession']['mode'] == 0) {
1966                        $timeModeAchievements[87] = true;
1967                    }
1968                }
1969            }
1970            if ($r[$i]['TimeModeSession']['points'] >= 850
1971            && ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '4k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1k'
1972            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '4d'
1973            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5d')) {
1974                $timeModeAchievements[91] = true;
1975            }
1976            if ($r[$i]['TimeModeSession']['points'] >= 875
1977            && ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '4k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1k'
1978            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '4d'
1979            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '6k')) {
1980                $timeModeAchievements[90] = true;
1981            }
1982            if ($r[$i]['TimeModeSession']['points'] >= 900
1983            && ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '4k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1k'
1984            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '4d'
1985            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '6k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '7k'
1986            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '8k')) {
1987                $timeModeAchievements[89] = true;
1988            }
1989            if ($r[$i]['TimeModeSession']['points'] >= 950
1990            && ($r[$i]['TimeModeSession']['TimeModeAttempt'] == '4k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1k'
1991            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '1d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '2d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '3d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '4d'
1992            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5d' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '5k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '6k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '7k'
1993            || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '8k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '9k' || $r[$i]['TimeModeSession']['TimeModeAttempt'] == '10k')) {
1994                $timeModeAchievements[88] = true;
1995            }
1996        }
1997        for ($i = 70; $i <= 91; $i++) {
1998            $achievementId = $i;
1999            if ($timeModeAchievements[$achievementId] == true && !isset($existingAs[$achievementId])) {
2000                $as['AchievementStatus']['achievement_id'] = $achievementId;
2001                ClassRegistry::init('AchievementStatus')->create();
2002                ClassRegistry::init('AchievementStatus')->save($as);
2003                array_push($updated, $achievementId);
2004            }
2005        }
2006        $updatedCount = count($updated);
2007        for ($i = 0; $i < $updatedCount; $i++) {
2008            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
2009            $updated[$i] = [];
2010            $updated[$i][0] = $a['Achievement']['name'];
2011            $updated[$i][1] = $a['Achievement']['description'];
2012            $updated[$i][2] = $a['Achievement']['image'];
2013            $updated[$i][3] = $a['Achievement']['color'];
2014            $updated[$i][4] = $a['Achievement']['xp'];
2015            $updated[$i][5] = $a['Achievement']['id'];
2016        }
2017
2018        return $updated;
2019    }
2020
2021    public static function checkRatingAchievements() {
2022        if (!Auth::isLoggedIn()) {
2023            return;
2024        }
2025
2026        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
2027        if (!$buffer) {
2028            $buffer = [];
2029        }
2030        $existingAs = [];
2031        $bufferCount = count($buffer);
2032        for ($i = 0; $i < $bufferCount; $i++) {
2033            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
2034        }
2035        $as = [];
2036        $as['AchievementStatus']['user_id'] = Auth::getUserID();
2037        $updated = [];
2038
2039        $achievementId = 59;
2040        $currentElo = Auth::getUser()['rating'];
2041        if ($currentElo >= 1500 && !isset($existingAs[$achievementId])) {
2042            $as['AchievementStatus']['achievement_id'] = $achievementId;
2043            ClassRegistry::init('AchievementStatus')->create();
2044            ClassRegistry::init('AchievementStatus')->save($as);
2045            array_push($updated, $achievementId);
2046        }
2047        $achievementId = 60;
2048        if ($currentElo >= 1600 && !isset($existingAs[$achievementId])) {
2049            $as['AchievementStatus']['achievement_id'] = $achievementId;
2050            ClassRegistry::init('AchievementStatus')->create();
2051            ClassRegistry::init('AchievementStatus')->save($as);
2052            array_push($updated, $achievementId);
2053        }
2054        $achievementId = 61;
2055        if ($currentElo >= 1700 && !isset($existingAs[$achievementId])) {
2056            $as['AchievementStatus']['achievement_id'] = $achievementId;
2057            ClassRegistry::init('AchievementStatus')->create();
2058            ClassRegistry::init('AchievementStatus')->save($as);
2059            array_push($updated, $achievementId);
2060        }
2061        $achievementId = 62;
2062        if ($currentElo >= 1800 && !isset($existingAs[$achievementId])) {
2063            $as['AchievementStatus']['achievement_id'] = $achievementId;
2064            ClassRegistry::init('AchievementStatus')->create();
2065            ClassRegistry::init('AchievementStatus')->save($as);
2066            array_push($updated, $achievementId);
2067        }
2068        $achievementId = 63;
2069        if ($currentElo >= 1900 && !isset($existingAs[$achievementId])) {
2070            $as['AchievementStatus']['achievement_id'] = $achievementId;
2071            ClassRegistry::init('AchievementStatus')->create();
2072            ClassRegistry::init('AchievementStatus')->save($as);
2073            array_push($updated, $achievementId);
2074        }
2075        $achievementId = 64;
2076        if ($currentElo >= 2000 && !isset($existingAs[$achievementId])) {
2077            $as['AchievementStatus']['achievement_id'] = $achievementId;
2078            ClassRegistry::init('AchievementStatus')->create();
2079            ClassRegistry::init('AchievementStatus')->save($as);
2080            array_push($updated, $achievementId);
2081        }
2082        $achievementId = 65;
2083        if ($currentElo >= 2100 && !isset($existingAs[$achievementId])) {
2084            $as['AchievementStatus']['achievement_id'] = $achievementId;
2085            ClassRegistry::init('AchievementStatus')->create();
2086            ClassRegistry::init('AchievementStatus')->save($as);
2087            array_push($updated, $achievementId);
2088        }
2089        $achievementId = 66;
2090        if ($currentElo >= 2200 && !isset($existingAs[$achievementId])) {
2091            $as['AchievementStatus']['achievement_id'] = $achievementId;
2092            ClassRegistry::init('AchievementStatus')->create();
2093            ClassRegistry::init('AchievementStatus')->save($as);
2094            array_push($updated, $achievementId);
2095        }
2096        $achievementId = 67;
2097        if ($currentElo >= 2300 && !isset($existingAs[$achievementId])) {
2098            $as['AchievementStatus']['achievement_id'] = $achievementId;
2099            ClassRegistry::init('AchievementStatus')->create();
2100            ClassRegistry::init('AchievementStatus')->save($as);
2101            array_push($updated, $achievementId);
2102        }
2103        $achievementId = 68;
2104        if ($currentElo >= 2400 && !isset($existingAs[$achievementId])) {
2105            $as['AchievementStatus']['achievement_id'] = $achievementId;
2106            ClassRegistry::init('AchievementStatus')->create();
2107            ClassRegistry::init('AchievementStatus')->save($as);
2108            array_push($updated, $achievementId);
2109        }
2110        $achievementId = 69;
2111        if ($currentElo >= 2500 && !isset($existingAs[$achievementId])) {
2112            $as['AchievementStatus']['achievement_id'] = $achievementId;
2113            ClassRegistry::init('AchievementStatus')->create();
2114            ClassRegistry::init('AchievementStatus')->save($as);
2115            array_push($updated, $achievementId);
2116        }
2117        $updatedCount = count($updated);
2118        for ($i = 0; $i < $updatedCount; $i++) {
2119            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
2120            $updated[$i] = [];
2121            $updated[$i][0] = $a['Achievement']['name'];
2122            $updated[$i][1] = $a['Achievement']['description'];
2123            $updated[$i][2] = $a['Achievement']['image'];
2124            $updated[$i][3] = $a['Achievement']['color'];
2125            $updated[$i][4] = $a['Achievement']['xp'];
2126            $updated[$i][5] = $a['Achievement']['id'];
2127        }
2128
2129        return $updated;
2130    }
2131
2132    public static function checkLevelAchievements() {
2133        if (!Auth::isLoggedIn()) {
2134            return;
2135        }
2136        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
2137        if (!$buffer) {
2138            $buffer = [];
2139        }
2140        $existingAs = [];
2141        $bufferCount = count($buffer);
2142        for ($i = 0; $i < $bufferCount; $i++) {
2143            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
2144        }
2145        $as = [];
2146        $as['AchievementStatus']['user_id'] = Auth::getUserID();
2147        $updated = [];
2148
2149        $achievementId = 36;
2150        $userLevel = Auth::getUser()['level'];
2151        if ($userLevel >= 10 && !isset($existingAs[$achievementId])) {
2152            $as['AchievementStatus']['achievement_id'] = $achievementId;
2153            ClassRegistry::init('AchievementStatus')->create();
2154            ClassRegistry::init('AchievementStatus')->save($as);
2155            array_push($updated, $achievementId);
2156        }
2157        $achievementId = 37;
2158        if ($userLevel >= 20 && !isset($existingAs[$achievementId])) {
2159            $as['AchievementStatus']['achievement_id'] = $achievementId;
2160            ClassRegistry::init('AchievementStatus')->create();
2161            ClassRegistry::init('AchievementStatus')->save($as);
2162            array_push($updated, $achievementId);
2163        }
2164        $achievementId = 38;
2165        if ($userLevel >= 30 && !isset($existingAs[$achievementId])) {
2166            $as['AchievementStatus']['achievement_id'] = $achievementId;
2167            ClassRegistry::init('AchievementStatus')->create();
2168            ClassRegistry::init('AchievementStatus')->save($as);
2169            array_push($updated, $achievementId);
2170        }
2171        $achievementId = 39;
2172        if ($userLevel >= 40 && !isset($existingAs[$achievementId])) {
2173            $as['AchievementStatus']['achievement_id'] = $achievementId;
2174            ClassRegistry::init('AchievementStatus')->create();
2175            ClassRegistry::init('AchievementStatus')->save($as);
2176            array_push($updated, $achievementId);
2177        }
2178        $achievementId = 40;
2179        if ($userLevel >= 50 && !isset($existingAs[$achievementId])) {
2180            $as['AchievementStatus']['achievement_id'] = $achievementId;
2181            ClassRegistry::init('AchievementStatus')->create();
2182            ClassRegistry::init('AchievementStatus')->save($as);
2183            array_push($updated, $achievementId);
2184        }
2185        $achievementId = 41;
2186        if ($userLevel >= 60 && !isset($existingAs[$achievementId])) {
2187            $as['AchievementStatus']['achievement_id'] = $achievementId;
2188            ClassRegistry::init('AchievementStatus')->create();
2189            ClassRegistry::init('AchievementStatus')->save($as);
2190            array_push($updated, $achievementId);
2191        }
2192        $achievementId = 42;
2193        if ($userLevel >= 70 && !isset($existingAs[$achievementId])) {
2194            $as['AchievementStatus']['achievement_id'] = $achievementId;
2195            ClassRegistry::init('AchievementStatus')->create();
2196            ClassRegistry::init('AchievementStatus')->save($as);
2197            array_push($updated, $achievementId);
2198        }
2199        $achievementId = 43;
2200        if ($userLevel >= 80 && !isset($existingAs[$achievementId])) {
2201            $as['AchievementStatus']['achievement_id'] = $achievementId;
2202            ClassRegistry::init('AchievementStatus')->create();
2203            ClassRegistry::init('AchievementStatus')->save($as);
2204            array_push($updated, $achievementId);
2205        }
2206        $achievementId = 44;
2207        if ($userLevel >= 90 && !isset($existingAs[$achievementId])) {
2208            $as['AchievementStatus']['achievement_id'] = $achievementId;
2209            ClassRegistry::init('AchievementStatus')->create();
2210            ClassRegistry::init('AchievementStatus')->save($as);
2211            array_push($updated, $achievementId);
2212        }
2213        $achievementId = 45;
2214        if ($userLevel >= 100 && !isset($existingAs[$achievementId])) {
2215            $as['AchievementStatus']['achievement_id'] = $achievementId;
2216            ClassRegistry::init('AchievementStatus')->create();
2217            ClassRegistry::init('AchievementStatus')->save($as);
2218            array_push($updated, $achievementId);
2219        }
2220        $achievementId = 100;
2221        if (Auth::hasPremium() && !isset($existingAs[$achievementId])) {
2222            $as['AchievementStatus']['achievement_id'] = $achievementId;
2223            ClassRegistry::init('AchievementStatus')->create();
2224            ClassRegistry::init('AchievementStatus')->save($as);
2225            array_push($updated, $achievementId);
2226        }
2227        $updatedCount = count($updated);
2228        for ($i = 0; $i < $updatedCount; $i++) {
2229            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
2230            $updated[$i] = [];
2231            $updated[$i][0] = $a['Achievement']['name'];
2232            $updated[$i][1] = $a['Achievement']['description'];
2233            $updated[$i][2] = $a['Achievement']['image'];
2234            $updated[$i][3] = $a['Achievement']['color'];
2235            $updated[$i][4] = $a['Achievement']['xp'];
2236            $updated[$i][5] = $a['Achievement']['id'];
2237        }
2238
2239        return $updated;
2240    }
2241
2242    protected function checkSetCompletedAchievements() {
2243        $this->loadModel('Set');
2244        $this->loadModel('Tsumego');
2245        $this->loadModel('Achievement');
2246        $this->loadModel('AchievementStatus');
2247        $this->loadModel('AchievementCondition');
2248
2249        $ac = ClassRegistry::init('AchievementCondition')->find('first', [
2250            'order' => 'value DESC',
2251            'conditions' => [
2252                'user_id' => Auth::getUserID(),
2253                'category' => 'set',
2254            ],
2255        ]);
2256
2257        if (!$ac) {
2258            return [];
2259        }
2260
2261        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
2262        if (!$buffer) {
2263            $buffer = [];
2264        }
2265        $existingAs = [];
2266        $bufferCount = count($buffer);
2267        for ($i = 0; $i < $bufferCount; $i++) {
2268            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
2269        }
2270        $as = [];
2271        $as['AchievementStatus']['user_id'] = Auth::getUserID();
2272        $updated = [];
2273
2274        $achievementId = 47;
2275        if ($ac['AchievementCondition']['value'] >= 10 && !isset($existingAs[$achievementId])) {
2276            $as['AchievementStatus']['achievement_id'] = $achievementId;
2277            ClassRegistry::init('AchievementStatus')->create();
2278            ClassRegistry::init('AchievementStatus')->save($as);
2279            array_push($updated, $achievementId);
2280        }
2281        $achievementId = 48;
2282        if ($ac['AchievementCondition']['value'] >= 20 && !isset($existingAs[$achievementId])) {
2283            $as['AchievementStatus']['achievement_id'] = $achievementId;
2284            ClassRegistry::init('AchievementStatus')->create();
2285            ClassRegistry::init('AchievementStatus')->save($as);
2286            array_push($updated, $achievementId);
2287        }
2288        $achievementId = 49;
2289        if ($ac['AchievementCondition']['value'] >= 30 && !isset($existingAs[$achievementId])) {
2290            $as['AchievementStatus']['achievement_id'] = $achievementId;
2291            ClassRegistry::init('AchievementStatus')->create();
2292            ClassRegistry::init('AchievementStatus')->save($as);
2293            array_push($updated, $achievementId);
2294        }
2295        $achievementId = 50;
2296        if ($ac['AchievementCondition']['value'] >= 40 && !isset($existingAs[$achievementId])) {
2297            $as['AchievementStatus']['achievement_id'] = $achievementId;
2298            ClassRegistry::init('AchievementStatus')->create();
2299            ClassRegistry::init('AchievementStatus')->save($as);
2300            array_push($updated, $achievementId);
2301        }
2302        $achievementId = 51;
2303        if ($ac['AchievementCondition']['value'] >= 50 && !isset($existingAs[$achievementId])) {
2304            $as['AchievementStatus']['achievement_id'] = $achievementId;
2305            ClassRegistry::init('AchievementStatus')->create();
2306            ClassRegistry::init('AchievementStatus')->save($as);
2307            array_push($updated, $achievementId);
2308        }
2309        $achievementId = 52;
2310        if ($ac['AchievementCondition']['value'] >= 60 && !isset($existingAs[$achievementId])) {
2311            $as['AchievementStatus']['achievement_id'] = $achievementId;
2312            ClassRegistry::init('AchievementStatus')->create();
2313            ClassRegistry::init('AchievementStatus')->save($as);
2314            array_push($updated, $achievementId);
2315        }
2316        $updatedCount = count($updated);
2317        for ($i = 0; $i < $updatedCount; $i++) {
2318            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
2319            $updated[$i] = [];
2320            $updated[$i][0] = $a['Achievement']['name'];
2321            $updated[$i][1] = $a['Achievement']['description'];
2322            $updated[$i][2] = $a['Achievement']['image'];
2323            $updated[$i][3] = $a['Achievement']['color'];
2324            $updated[$i][4] = $a['Achievement']['xp'];
2325            $updated[$i][5] = $a['Achievement']['id'];
2326        }
2327
2328        return $updated;
2329    }
2330
2331    protected function setAchievementSpecial($s = null) {
2332        $this->loadModel('Set');
2333        $this->loadModel('Tsumego');
2334        $this->loadModel('TsumegoStatus');
2335        $this->loadModel('Achievement');
2336        $this->loadModel('AchievementStatus');
2337        $this->loadModel('SetConnection');
2338
2339        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
2340        if (!$buffer) {
2341            $buffer = [];
2342        }
2343        $existingAs = [];
2344        $bufferCount = count($buffer);
2345        for ($i = 0; $i < $bufferCount; $i++) {
2346            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
2347        }
2348        $as = [];
2349        $as['AchievementStatus']['user_id'] = Auth::getUserID();
2350        $updated = [];
2351
2352        $tsIds = [];
2353        $completed = '';
2354        if ($s == 'cc1') {
2355            $ts1 = TsumegoUtil::collectTsumegosFromSet(50);
2356            $ts2 = TsumegoUtil::collectTsumegosFromSet(52);
2357            $ts3 = TsumegoUtil::collectTsumegosFromSet(53);
2358            $ts4 = TsumegoUtil::collectTsumegosFromSet(54);
2359            $ts = array_merge($ts1, $ts2, $ts3, $ts4);
2360            $tsCount = count($ts);
2361            for ($i = 0; $i < $tsCount; $i++) {
2362                array_push($tsIds, $ts[$i]['Tsumego']['id']);
2363            }
2364            $uts = $this->TsumegoStatus->find('all', [
2365                'conditions' => [
2366                    'user_id' => Auth::getUserID(),
2367                    'tsumego_id' => $tsIds,
2368                ],
2369            ]);
2370            if (!$uts) {
2371                $uts = [];
2372            }
2373            $counter = 0;
2374            $utsCount = count($uts);
2375            for ($j = 0; $j < $utsCount; $j++) {
2376                for ($k = 0; $k < $tsCount; $k++) {
2377                    if ($uts[$j]['TsumegoStatus']['tsumego_id'] == $ts[$k]['Tsumego']['id'] && ($uts[$j]['TsumegoStatus']['status'] == 'S'
2378                    || $uts[$j]['TsumegoStatus']['status'] == 'W' || $uts[$j]['TsumegoStatus']['status'] == 'C')) {
2379                        $counter++;
2380                    }
2381                }
2382            }
2383            if ($counter == count($ts)) {
2384                $completed = $s;
2385            }
2386        } elseif ($s == 'cc2') {
2387            $ts1 = TsumegoUtil::collectTsumegosFromSet(41);
2388            $ts2 = TsumegoUtil::collectTsumegosFromSet(49);
2389            $ts3 = TsumegoUtil::collectTsumegosFromSet(65);
2390            $ts4 = TsumegoUtil::collectTsumegosFromSet(66);
2391            $ts = array_merge($ts1, $ts2, $ts3, $ts4);
2392            $tsCount = count($ts);
2393            for ($i = 0; $i < $tsCount; $i++) {
2394                array_push($tsIds, $ts[$i]['Tsumego']['id']);
2395            }
2396            $uts = $this->TsumegoStatus->find('all', [
2397                'conditions' => [
2398                    'user_id' => Auth::getUserID(),
2399                    'tsumego_id' => $tsIds,
2400                ],
2401            ]);
2402            if (!$uts) {
2403                $uts = [];
2404            }
2405            $counter = 0;
2406            $utsCount = count($uts);
2407            for ($j = 0; $j < $utsCount; $j++) {
2408                for ($k = 0; $k < $tsCount; $k++) {
2409                    if ($uts[$j]['TsumegoStatus']['tsumego_id'] == $ts[$k]['Tsumego']['id'] && ($uts[$j]['TsumegoStatus']['status'] == 'S'
2410                    || $uts[$j]['TsumegoStatus']['status'] == 'W' || $uts[$j]['TsumegoStatus']['status'] == 'C')) {
2411                        $counter++;
2412                    }
2413                }
2414            }
2415            if ($counter == count($ts)) {
2416                $completed = $s;
2417            }
2418        } elseif ($s == 'cc3') {
2419            $ts1 = TsumegoUtil::collectTsumegosFromSet(186);
2420            $ts2 = TsumegoUtil::collectTsumegosFromSet(187);
2421            $ts3 = TsumegoUtil::collectTsumegosFromSet(196);
2422            $ts4 = TsumegoUtil::collectTsumegosFromSet(203);
2423            $ts = array_merge($ts1, $ts2, $ts3, $ts4);
2424            $tsCount = count($ts);
2425            for ($i = 0; $i < $tsCount; $i++) {
2426                array_push($tsIds, $ts[$i]['Tsumego']['id']);
2427            }
2428            $uts = $this->TsumegoStatus->find('all', [
2429                'conditions' => [
2430                    'user_id' => Auth::getUserID(),
2431                    'tsumego_id' => $tsIds,
2432                ],
2433            ]);
2434            if (!$uts) {
2435                $uts = [];
2436            }
2437            $counter = 0;
2438            $utsCount = count($uts);
2439            for ($j = 0; $j < $utsCount; $j++) {
2440                for ($k = 0; $k < $tsCount; $k++) {
2441                    if ($uts[$j]['TsumegoStatus']['tsumego_id'] == $ts[$k]['Tsumego']['id'] && ($uts[$j]['TsumegoStatus']['status'] == 'S'
2442                    || $uts[$j]['TsumegoStatus']['status'] == 'W' || $uts[$j]['TsumegoStatus']['status'] == 'C')) {
2443                        $counter++;
2444                    }
2445                }
2446            }
2447            if ($counter == count($ts)) {
2448                $completed = $s;
2449            }
2450        } elseif ($s == '1000w1') {
2451            $ts1 = TsumegoUtil::collectTsumegosFromSet(190);
2452            $ts2 = TsumegoUtil::collectTsumegosFromSet(193);
2453            $ts3 = TsumegoUtil::collectTsumegosFromSet(198);
2454            $ts = array_merge($ts1, $ts2, $ts3);
2455            $tsCount = count($ts);
2456            for ($i = 0; $i < $tsCount; $i++) {
2457                array_push($tsIds, $ts[$i]['Tsumego']['id']);
2458            }
2459            $uts = $this->TsumegoStatus->find('all', [
2460                'conditions' => [
2461                    'user_id' => Auth::getUserID(),
2462                    'tsumego_id' => $tsIds,
2463                ],
2464            ]);
2465            if (!$uts) {
2466                $uts = [];
2467            }
2468            $counter = 0;
2469            $utsCount = count($uts);
2470            for ($j = 0; $j < $utsCount; $j++) {
2471                for ($k = 0; $k < $tsCount; $k++) {
2472                    if ($uts[$j]['TsumegoStatus']['tsumego_id'] == $ts[$k]['Tsumego']['id'] && ($uts[$j]['TsumegoStatus']['status'] == 'S'
2473                    || $uts[$j]['TsumegoStatus']['status'] == 'W' || $uts[$j]['TsumegoStatus']['status'] == 'C')) {
2474                        $counter++;
2475                    }
2476                }
2477            }
2478            if ($counter == count($ts)) {
2479                $completed = $s;
2480            }
2481        } elseif ($s == '1000w2') {
2482            $ts = TsumegoUtil::collectTsumegosFromSet(216);
2483            $tsCount = count($ts);
2484            for ($i = 0; $i < $tsCount; $i++) {
2485                array_push($tsIds, $ts[$i]['Tsumego']['id']);
2486            }
2487            $uts = $this->TsumegoStatus->find('all', [
2488                'conditions' => [
2489                    'user_id' => Auth::getUserID(),
2490                    'tsumego_id' => $tsIds,
2491                ],
2492            ]);
2493            if (!$uts) {
2494                $uts = [];
2495            }
2496            $counter = 0;
2497            $utsCount = count($uts);
2498            for ($j = 0; $j < $utsCount; $j++) {
2499                for ($k = 0; $k < $tsCount; $k++) {
2500                    if ($uts[$j]['TsumegoStatus']['tsumego_id'] == $ts[$k]['Tsumego']['id'] && ($uts[$j]['TsumegoStatus']['status'] == 'S'
2501                    || $uts[$j]['TsumegoStatus']['status'] == 'W' || $uts[$j]['TsumegoStatus']['status'] == 'C')) {
2502                        $counter++;
2503                    }
2504                }
2505            }
2506            if ($counter == count($ts)) {
2507                $completed = $s;
2508            }
2509        }
2510
2511        $achievementId = 92;
2512        if ($completed == 'cc1' && !isset($existingAs[$achievementId])) {
2513            $as['AchievementStatus']['achievement_id'] = $achievementId;
2514            ClassRegistry::init('AchievementStatus')->create();
2515            ClassRegistry::init('AchievementStatus')->save($as);
2516            array_push($updated, $achievementId);
2517        }
2518        $achievementId = 93;
2519        if ($completed == 'cc2' && !isset($existingAs[$achievementId])) {
2520            $as['AchievementStatus']['achievement_id'] = $achievementId;
2521            ClassRegistry::init('AchievementStatus')->create();
2522            ClassRegistry::init('AchievementStatus')->save($as);
2523            array_push($updated, $achievementId);
2524        }
2525        $achievementId = 94;
2526        if ($completed == 'cc3' && !isset($existingAs[$achievementId])) {
2527            $as['AchievementStatus']['achievement_id'] = $achievementId;
2528            ClassRegistry::init('AchievementStatus')->create();
2529            ClassRegistry::init('AchievementStatus')->save($as);
2530            array_push($updated, $achievementId);
2531        }
2532        $achievementId = 95;
2533        if ($completed == '1000w1' && !isset($existingAs[$achievementId])) {
2534            $as['AchievementStatus']['achievement_id'] = $achievementId;
2535            ClassRegistry::init('AchievementStatus')->create();
2536            ClassRegistry::init('AchievementStatus')->save($as);
2537            array_push($updated, $achievementId);
2538        }
2539        $achievementId = 115;
2540        if ($completed == '1000w2' && !isset($existingAs[$achievementId])) {
2541            $as['AchievementStatus']['achievement_id'] = $achievementId;
2542            ClassRegistry::init('AchievementStatus')->create();
2543            ClassRegistry::init('AchievementStatus')->save($as);
2544            array_push($updated, $achievementId);
2545        }
2546        $updatedCount = count($updated);
2547        for ($i = 0; $i < $updatedCount; $i++) {
2548            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
2549            $updated[$i] = [];
2550            $updated[$i][0] = $a['Achievement']['name'];
2551            $updated[$i][1] = $a['Achievement']['description'];
2552            $updated[$i][2] = $a['Achievement']['image'];
2553            $updated[$i][3] = $a['Achievement']['color'];
2554            $updated[$i][4] = $a['Achievement']['xp'];
2555            $updated[$i][5] = $a['Achievement']['id'];
2556        }
2557
2558        return $updated;
2559    }
2560
2561    protected function checkSetAchievements($sid = null) {
2562        $this->loadModel('Set');
2563        $this->loadModel('Tsumego');
2564        $this->loadModel('Achievement');
2565        $this->loadModel('AchievementStatus');
2566        $this->loadModel('AchievementCondition');
2567
2568        //$tNum = count($this->Tsumego->find('all', array('conditions' => array('set_id' => $sid))));
2569        $tNum = count(TsumegoUtil::collectTsumegosFromSet($sid));
2570        $s = $this->Set->findById($sid);
2571        $acA = ClassRegistry::init('AchievementCondition')->find('first', [
2572            'order' => 'value DESC',
2573            'conditions' => [
2574                'set_id' => $sid,
2575                'user_id' => Auth::getUserID(),
2576                'category' => '%',
2577            ],
2578        ]);
2579        if (!$acA) {
2580            return [];
2581        }
2582        $acS = ClassRegistry::init('AchievementCondition')->find('first', [
2583            'order' => 'value ASC',
2584            'conditions' => [
2585                'set_id' => $sid,
2586                'user_id' => Auth::getUserID(),
2587                'category' => 's',
2588            ],
2589        ]);
2590        $buffer = ClassRegistry::init('AchievementStatus')->find('all', ['conditions' => ['user_id' => Auth::getUserID()]]);
2591        if (!$buffer) {
2592            $buffer = [];
2593        }
2594        $existingAs = [];
2595        $bufferCount = count($buffer);
2596        for ($i = 0; $i < $bufferCount; $i++) {
2597            $existingAs[$buffer[$i]['AchievementStatus']['achievement_id']] = $buffer[$i];
2598        }
2599        $as = [];
2600        $as['AchievementStatus']['user_id'] = Auth::getUserID();
2601        $updated = [];
2602
2603        $achievementId = 99;
2604        if ($sid == -1 && !isset($existingAs[$achievementId])) {
2605            $as['AchievementStatus']['achievement_id'] = $achievementId;
2606            ClassRegistry::init('AchievementStatus')->create();
2607            ClassRegistry::init('AchievementStatus')->save($as);
2608            array_push($updated, $achievementId);
2609        }
2610        if ($tNum >= 100) {
2611            if ($s['Set']['difficulty'] < 1300) {
2612                $achievementId = 12;
2613                if ($acA['AchievementCondition']['value'] >= 75 && !isset($existingAs[$achievementId])) {
2614                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2615                    ClassRegistry::init('AchievementStatus')->create();
2616                    ClassRegistry::init('AchievementStatus')->save($as);
2617                    array_push($updated, $achievementId);
2618                }
2619                $achievementId = 13;
2620                if ($acA['AchievementCondition']['value'] >= 85 && !isset($existingAs[$achievementId])) {
2621                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2622                    ClassRegistry::init('AchievementStatus')->create();
2623                    ClassRegistry::init('AchievementStatus')->save($as);
2624                    array_push($updated, $achievementId);
2625                }
2626                $achievementId = 14;
2627                if ($acA['AchievementCondition']['value'] >= 95 && !isset($existingAs[$achievementId])) {
2628                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2629                    ClassRegistry::init('AchievementStatus')->create();
2630                    ClassRegistry::init('AchievementStatus')->save($as);
2631                    array_push($updated, $achievementId);
2632                }
2633                $achievementId = 24;
2634                if ($acS['AchievementCondition']['value'] < 15 && !isset($existingAs[$achievementId])) {
2635                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2636                    ClassRegistry::init('AchievementStatus')->create();
2637                    ClassRegistry::init('AchievementStatus')->save($as);
2638                    array_push($updated, $achievementId);
2639                }
2640                $achievementId = 25;
2641                if ($acS['AchievementCondition']['value'] < 10 && !isset($existingAs[$achievementId])) {
2642                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2643                    ClassRegistry::init('AchievementStatus')->create();
2644                    ClassRegistry::init('AchievementStatus')->save($as);
2645                    array_push($updated, $achievementId);
2646                }
2647                $achievementId = 26;
2648                if ($acS['AchievementCondition']['value'] < 5 && !isset($existingAs[$achievementId])) {
2649                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2650                    ClassRegistry::init('AchievementStatus')->create();
2651                    ClassRegistry::init('AchievementStatus')->save($as);
2652                    array_push($updated, $achievementId);
2653                }
2654            } elseif ($s['Set']['difficulty'] >= 1300 && $s['Set']['difficulty'] < 1500) {
2655                $achievementId = 15;
2656                if ($acA['AchievementCondition']['value'] >= 75 && !isset($existingAs[$achievementId])) {
2657                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2658                    ClassRegistry::init('AchievementStatus')->create();
2659                    ClassRegistry::init('AchievementStatus')->save($as);
2660                    array_push($updated, $achievementId);
2661                }
2662                $achievementId = 16;
2663                if ($acA['AchievementCondition']['value'] >= 85 && !isset($existingAs[$achievementId])) {
2664                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2665                    ClassRegistry::init('AchievementStatus')->create();
2666                    ClassRegistry::init('AchievementStatus')->save($as);
2667                    array_push($updated, $achievementId);
2668                }
2669                $achievementId = 17;
2670                if ($acA['AchievementCondition']['value'] >= 95 && !isset($existingAs[$achievementId])) {
2671                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2672                    ClassRegistry::init('AchievementStatus')->create();
2673                    ClassRegistry::init('AchievementStatus')->save($as);
2674                    array_push($updated, $achievementId);
2675                }
2676                $achievementId = 27;
2677                if ($acS['AchievementCondition']['value'] < 18 && !isset($existingAs[$achievementId])) {
2678                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2679                    ClassRegistry::init('AchievementStatus')->create();
2680                    ClassRegistry::init('AchievementStatus')->save($as);
2681                    array_push($updated, $achievementId);
2682                }
2683                $achievementId = 28;
2684                if ($acS['AchievementCondition']['value'] < 13 && !isset($existingAs[$achievementId])) {
2685                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2686                    ClassRegistry::init('AchievementStatus')->create();
2687                    ClassRegistry::init('AchievementStatus')->save($as);
2688                    array_push($updated, $achievementId);
2689                }
2690                $achievementId = 29;
2691                if ($acS['AchievementCondition']['value'] < 8 && !isset($existingAs[$achievementId])) {
2692                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2693                    ClassRegistry::init('AchievementStatus')->create();
2694                    ClassRegistry::init('AchievementStatus')->save($as);
2695                    array_push($updated, $achievementId);
2696                }
2697            } elseif ($s['Set']['difficulty'] >= 1500 && $s['Set']['difficulty'] < 1700) {
2698                $achievementId = 18;
2699                if ($acA['AchievementCondition']['value'] >= 75 && !isset($existingAs[$achievementId])) {
2700                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2701                    ClassRegistry::init('AchievementStatus')->create();
2702                    ClassRegistry::init('AchievementStatus')->save($as);
2703                    array_push($updated, $achievementId);
2704                }
2705                $achievementId = 19;
2706                if ($acA['AchievementCondition']['value'] >= 85 && !isset($existingAs[$achievementId])) {
2707                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2708                    ClassRegistry::init('AchievementStatus')->create();
2709                    ClassRegistry::init('AchievementStatus')->save($as);
2710                    array_push($updated, $achievementId);
2711                }
2712                $achievementId = 20;
2713                if ($acA['AchievementCondition']['value'] >= 95 && !isset($existingAs[$achievementId])) {
2714                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2715                    ClassRegistry::init('AchievementStatus')->create();
2716                    ClassRegistry::init('AchievementStatus')->save($as);
2717                    array_push($updated, $achievementId);
2718                }
2719                $achievementId = 30;
2720                if ($acS['AchievementCondition']['value'] < 30 && !isset($existingAs[$achievementId])) {
2721                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2722                    ClassRegistry::init('AchievementStatus')->create();
2723                    ClassRegistry::init('AchievementStatus')->save($as);
2724                    array_push($updated, $achievementId);
2725                }
2726                $achievementId = 31;
2727                if ($acS['AchievementCondition']['value'] < 20 && !isset($existingAs[$achievementId])) {
2728                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2729                    ClassRegistry::init('AchievementStatus')->create();
2730                    ClassRegistry::init('AchievementStatus')->save($as);
2731                    array_push($updated, $achievementId);
2732                }
2733                $achievementId = 32;
2734                if ($acS['AchievementCondition']['value'] < 10 && !isset($existingAs[$achievementId])) {
2735                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2736                    ClassRegistry::init('AchievementStatus')->create();
2737                    ClassRegistry::init('AchievementStatus')->save($as);
2738                    array_push($updated, $achievementId);
2739                }
2740            } else {
2741                $achievementId = 21;
2742                if ($acA['AchievementCondition']['value'] >= 75 && !isset($existingAs[$achievementId])) {
2743                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2744                    ClassRegistry::init('AchievementStatus')->create();
2745                    ClassRegistry::init('AchievementStatus')->save($as);
2746                    array_push($updated, $achievementId);
2747                }
2748                $achievementId = 22;
2749                if ($acA['AchievementCondition']['value'] >= 85 && !isset($existingAs[$achievementId])) {
2750                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2751                    ClassRegistry::init('AchievementStatus')->create();
2752                    ClassRegistry::init('AchievementStatus')->save($as);
2753                    array_push($updated, $achievementId);
2754                }
2755                $achievementId = 23;
2756                if ($acA['AchievementCondition']['value'] >= 95 && !isset($existingAs[$achievementId])) {
2757                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2758                    ClassRegistry::init('AchievementStatus')->create();
2759                    ClassRegistry::init('AchievementStatus')->save($as);
2760                    array_push($updated, $achievementId);
2761                }
2762                $achievementId = 33;
2763                if ($acS['AchievementCondition']['value'] < 30 && !isset($existingAs[$achievementId])) {
2764                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2765                    ClassRegistry::init('AchievementStatus')->create();
2766                    ClassRegistry::init('AchievementStatus')->save($as);
2767                    array_push($updated, $achievementId);
2768                }
2769                $achievementId = 34;
2770                if ($acS['AchievementCondition']['value'] < 20 && !isset($existingAs[$achievementId])) {
2771                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2772                    ClassRegistry::init('AchievementStatus')->create();
2773                    ClassRegistry::init('AchievementStatus')->save($as);
2774                    array_push($updated, $achievementId);
2775                }
2776                $achievementId = 35;
2777                if ($acS['AchievementCondition']['value'] < 10 && !isset($existingAs[$achievementId])) {
2778                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2779                    ClassRegistry::init('AchievementStatus')->create();
2780                    ClassRegistry::init('AchievementStatus')->save($as);
2781                    array_push($updated, $achievementId);
2782                }
2783            }
2784            $achievementId = 46;
2785            if ($acA['AchievementCondition']['value'] >= 100) {
2786                $ac100 = ClassRegistry::init('AchievementCondition')->find('all', ['conditions' => ['user_id' => Auth::getUserID(), 'category' => '%', 'value >=' => 100]]);
2787                if (!$ac100) {
2788                    $ac100 = [];
2789                }
2790                $ac100counter = 0;
2791                $ac100Count = count($ac100);
2792                for ($j = 0; $j < $ac100Count; $j++) {
2793                    if (count(TsumegoUtil::collectTsumegosFromSet($ac100[$j]['AchievementCondition']['set_id'])) >= 100) {
2794                        $ac100counter++;
2795                    }
2796                }
2797                $as100 = ClassRegistry::init('AchievementStatus')->find('first', ['conditions' => ['user_id' => Auth::getUserID(), 'achievement_id' => $achievementId]]);
2798                if ($as100 == null) {
2799                    $as['AchievementStatus']['achievement_id'] = $achievementId;
2800                    $as['AchievementStatus']['value'] = 1;
2801                    ClassRegistry::init('AchievementStatus')->create();
2802                    ClassRegistry::init('AchievementStatus')->save($as);
2803                    array_push($updated, $achievementId);
2804                } elseif ($as100['AchievementStatus']['value'] != $ac100counter) {
2805                    $as100['AchievementStatus']['value'] = $ac100counter;
2806                    ClassRegistry::init('AchievementStatus')->save($as100);
2807                    array_push($updated, $achievementId);
2808                }
2809            }
2810        }
2811        $updatedCount = count($updated);
2812        for ($i = 0; $i < $updatedCount; $i++) {
2813            $a = ClassRegistry::init('Achievement')->findById($updated[$i]);
2814            $updated[$i] = [];
2815            $updated[$i][0] = $a['Achievement']['name'];
2816            $updated[$i][1] = $a['Achievement']['description'];
2817            $updated[$i][2] = $a['Achievement']['image'];
2818            $updated[$i][3] = $a['Achievement']['color'];
2819            $updated[$i][4] = $a['Achievement']['xp'];
2820            $updated[$i][5] = $a['Achievement']['id'];
2821        }
2822
2823        return $updated;
2824    }
2825
2826    public static function getXPJump($lvl = null): int {
2827        if ($lvl >= 102) {
2828            return 0;
2829        }
2830        if ($lvl == 101) {
2831            return 1150;
2832        }
2833        if ($lvl == 100) {
2834            return 50000;
2835        }
2836        if ($lvl >= 70) {
2837            return 150;
2838        }
2839        if ($lvl >= 40) {
2840            return 100;
2841        }
2842        if ($lvl >= 20) {
2843            return 50;
2844        }
2845        if ($lvl >= 12) {
2846            return 25;
2847        }
2848
2849        return 10;
2850    }
2851
2852    public static function updateXP($userID, $achievementData): void {
2853        $xpBonus = 0;
2854        $aCount = count($achievementData);
2855        for ($i = 0; $i < $aCount; $i++) {
2856            $xpBonus += $achievementData[$i][4];
2857        }
2858        if ($xpBonus == 0) {
2859            return;
2860        }
2861        $user = ClassRegistry::init('User')->findById($userID);
2862        $user['User']['xp'] = $xpBonus;
2863        Level::checkLevelUp($user['User']);
2864        ClassRegistry::init('User')->save($user);
2865    }
2866
2867    public static function getPartitionRange($amountRemaining, $collectionSize, $partition) {
2868        if ($collectionSize > 0) {
2869            $amountPartitions = ceil($amountRemaining / $collectionSize);
2870        } else {
2871            return ['0', $collectionSize - 1];
2872        }
2873        if ($collectionSize > 0 && $amountRemaining % $collectionSize == 0) {
2874            return [ $partition * $collectionSize,  $partition * $collectionSize + $collectionSize - 1];
2875        }
2876        $amountCounter = 0;
2877        $amountFrom = 0;
2878        $amountTo = $collectionSize - 1;
2879        while ($amountRemaining > $collectionSize) {
2880            if ($partition == $amountCounter) {
2881                break;
2882            }
2883            $amountRemaining -= $collectionSize;
2884            $amountCounter++;
2885            $amountFrom += $collectionSize;
2886            $amountTo += $collectionSize;
2887        }
2888        $amountTo = $amountFrom + $collectionSize - 1;
2889        if ($partition >= $amountPartitions - 1) {
2890            $amountTo = $amountFrom + $amountRemaining - 1;
2891        }
2892        $a = [];
2893        $a[0] = $amountFrom;
2894        $a[1] = $amountTo;
2895
2896        return $a;
2897    }
2898
2899    /**
2900     * @param int $uid User ID
2901     * @return void
2902     */
2903    protected function handleSearchSettings($uid) {
2904        $this->loadModel('UserContribution');
2905        $uc = $this->UserContribution->find('first', ['conditions' => ['user_id' => $uid]]);
2906        if ($uc == null) {
2907            $uc = [];
2908            $uc['UserContribution']['user_id'] = $uid;
2909            $uc['UserContribution']['added_tag'] = 0;
2910            $uc['UserContribution']['created_tag'] = 0;
2911            $uc['UserContribution']['made_proposal'] = 0;
2912            $uc['UserContribution']['reviewed'] = 0;
2913            $uc['UserContribution']['score'] = 0;
2914            $this->UserContribution->create();
2915            $this->UserContribution->save($uc);
2916        }
2917        new TsumegoFilters();
2918    }
2919
2920    protected function signIn(array $user): void {
2921        Auth::init($user);
2922        $vs = $this->TsumegoStatus->find('first', ['conditions' => ['user_id' => $user['User']['id']], 'order' => 'created DESC']);
2923        if ($vs) {
2924            $this->Session->write('lastVisit', $vs['TsumegoStatus']['tsumego_id']);
2925        }
2926        $this->Session->write('texture', $user['User']['texture']);
2927        $this->Session->write('check1', $user['User']['id']);
2928    }
2929
2930    public function beforeFilter(): void {
2931        $this->loadModel('User');
2932        $this->loadModel('Activate');
2933        $this->loadModel('Tsumego');
2934        $this->loadModel('TsumegoRatingAttempt');
2935        $this->loadModel('Set');
2936        $this->loadModel('TimeModeAttempt');
2937        $this->loadModel('TsumegoStatus');
2938        $this->loadModel('Comment');
2939        $this->loadModel('UserBoard');
2940        $this->loadModel('TsumegoAttempt');
2941        $this->loadModel('AdminActivity');
2942        $this->loadModel('Achievement');
2943        $this->loadModel('AchievementStatus');
2944        $this->loadModel('AchievementCondition');
2945        $this->loadModel('SetConnection');
2946        $this->loadModel('Tag');
2947        $this->loadModel('TagName');
2948        $this->loadModel('Favorite');
2949
2950        Auth::init();
2951        $this->TimeMode->init();
2952
2953        $highscoreLink = 'highscore';
2954        $lightDark = 'light';
2955        $resetCookies = false;
2956        $levelBar = 1;
2957        $lastProfileLeft = 1;
2958        $lastProfileRight = 2;
2959        $hasFavs = false;
2960
2961        if (Auth::isLoggedIn()) {
2962            if (isset($_COOKIE['addTag']) && $_COOKIE['addTag'] != 0 && $this->Session->read('page') != 'set') {
2963                $newAddTag = explode('-', $_COOKIE['addTag']);
2964                $tagId = $newAddTag[0];
2965                $newTagName = $this->TagName->find('first', ['conditions' => ['name' => str_replace($tagId . '-', '', $_COOKIE['addTag'])]]);
2966                if ($newTagName) {
2967                    $saveTag = [];
2968                    $saveTag['Tag']['tag_name_id'] = $newTagName['TagName']['id'];
2969                    $saveTag['Tag']['tsumego_id'] = $tagId;
2970                    $saveTag['Tag']['user_id'] = Auth::getUserID();
2971                    $saveTag['Tag']['approved'] = 0;
2972                    $this->Tag->save($saveTag);
2973                }
2974                $this->set('removeCookie', 'addTag');
2975            }
2976            if (isset($_COOKIE['z_sess']) && $_COOKIE['z_sess'] != 0
2977            && strlen($_COOKIE['z_sess']) > 5) {
2978                Auth::getUser()['_sessid'] = $_COOKIE['z_sess'];
2979                Auth::saveUser();
2980            }
2981            if (Auth::getUser()['lastHighscore'] == 1) {
2982                $highscoreLink = 'highscore';
2983            } elseif (Auth::getUser()['lastHighscore'] == 2) {
2984                $highscoreLink = 'rating';
2985            } elseif (Auth::getUser()['lastHighscore'] == 3) {
2986                $highscoreLink = 'leaderboard';
2987            } elseif (Auth::getUser()['lastHighscore'] == 4) {
2988                $highscoreLink = 'highscore3';
2989            }
2990
2991            if (isset($_COOKIE['lastMode']) && $_COOKIE['lastMode'] != 0) {
2992                Auth::getUser()['lastMode'] = $_COOKIE['lastMode'];
2993                Auth::saveUser();
2994            }
2995            if (isset($_COOKIE['sound']) && $_COOKIE['sound'] != '0') {
2996                Auth::getUser()['sound'] = $_COOKIE['sound'];
2997                Auth::saveUser();
2998                unset($_COOKIE['sound']);
2999            }
3000            $this->set('ac', true);
3001            $this->set('user', Auth::getUser());
3002        }
3003
3004        if (isset($_COOKIE['lightDark']) && $_COOKIE['lightDark'] != '0') {
3005            $lightDark = $_COOKIE['lightDark'];
3006            if (Auth::isLoggedIn()) {
3007                // Convert string to integer for database storage
3008                $lightDarkInt = ($lightDark === 'light') ? 0 : 2;
3009                Auth::getUser()['lastLight'] = $lightDarkInt;
3010            }
3011        } elseif (Auth::isLoggedIn()) {
3012            if (Auth::getUser()['lastLight'] == 0
3013            || Auth::getUser()['lastLight'] == 1) {
3014                $lightDark = 'light';
3015            } else {
3016                $lightDark = 'dark';
3017            }
3018        }
3019
3020        if (Auth::isLoggedIn()) {
3021            $this->handleSearchSettings(Auth::getUserID());
3022            if (isset($_COOKIE['levelBar']) && $_COOKIE['levelBar'] != '0') {
3023                $levelBar = $_COOKIE['levelBar'];
3024                Auth::getUser()['levelBar'] = $levelBar;
3025            } elseif (Auth::getUser()['levelBar'] == 0
3026          || Auth::getUser()['levelBar'] == 'level') {
3027                $levelBar = 1;
3028            } else {
3029                $levelBar = 2;
3030            }
3031
3032            if (isset($_COOKIE['lastProfileLeft']) && $_COOKIE['lastProfileLeft'] != '0') {
3033                $lastProfileLeft = $_COOKIE['lastProfileLeft'];
3034                Auth::getUser()['lastProfileLeft'] = $lastProfileLeft;
3035            } else {
3036                $lastProfileLeft = Auth::getUser()['lastProfileLeft'];
3037                if ($lastProfileLeft == 0) {
3038                    $lastProfileLeft = 1;
3039                }
3040            }
3041            if (isset($_COOKIE['lastProfileRight']) && $_COOKIE['lastProfileRight'] != '0') {
3042                $lastProfileRight = $_COOKIE['lastProfileRight'];
3043                Auth::getUser()['lastProfileRight'] = $lastProfileRight;
3044            } else {
3045                $lastProfileRight = Auth::getUser()['lastProfileRight'];
3046                if ($lastProfileRight == 0) {
3047                    $lastProfileRight = 1;
3048                }
3049            }
3050        }
3051        $mode = 1;
3052        if (isset($_COOKIE['mode']) && $_COOKIE['mode'] != '0') {
3053            if ($_COOKIE['mode'] == 1) {
3054                $mode = 1;
3055            } else {
3056                $mode = 2;
3057            }
3058        }
3059
3060        if (Auth::isLoggedIn() && Auth::getUser()['mode'] == 2) {
3061            $mode = 2;
3062        }
3063
3064        if ($_COOKIE['sprint'] != 1) {
3065            $this->updateSprintCondition();
3066        }
3067        $correctSolveAttempt = false;
3068
3069        if (Auth::isLoggedIn()) {
3070            if (isset($_COOKIE['revelation']) && $_COOKIE['revelation'] != 0) {
3071                Auth::getUser()['revelation'] -= 1;
3072            }
3073
3074            if (!$this->request->is('ajax')) {
3075                $this->PlayResultProcessor->checkPreviousPlay($this->TimeMode);
3076            }
3077
3078            if (isset($_COOKIE['noScore']) && isset($_COOKIE['noPreId'])) {
3079                if ($_COOKIE['noScore'] != '0' && $_COOKIE['noPreId'] != '0') {
3080                    //$previosTsumegoX = $this->Tsumego->findById($_COOKIE['noPreId']);
3081                    //$previosTsumegoXsc = $this->SetConnection->find('first', array('conditions' => array('tsumego_id' => $_COOKIE['noPreId'])));
3082                    //$scoreArrX = explode('-', $this->decrypt($_COOKIE['noScore']));
3083
3084                    $utPreX = $this->TsumegoStatus->find('first', ['conditions' => ['tsumego_id' => $_COOKIE['noPreId'], 'user_id' => Auth::getUserID()]]);
3085                    if ($utPreX == null) {
3086                        $utPreX['TsumegoStatus'] = [];
3087                        $utPreX['TsumegoStatus']['user_id'] = Auth::getUserID();
3088                        $utPreX['TsumegoStatus']['tsumego_id'] = $_COOKIE['noPreId'];
3089                    }
3090                    if ($utPreX['TsumegoStatus']['status'] == 'W') {
3091                        $utPreX['TsumegoStatus']['status'] = 'C';
3092                    } else {
3093                        $utPreX['TsumegoStatus']['status'] = 'S';
3094                    }
3095                    $utPreX['TsumegoStatus']['created'] = date('Y-m-d H:i:s');
3096                    //$this->TsumegoStatus->save($utPreX);
3097                    //$sessionUts = $this->Session->read('loggedInUser.uts');
3098                    /*if (!$sessionUts) {
3099                    $sessionUts = [];
3100                    }
3101                    $sessionUts[$utPreX['TsumegoStatus']['tsumego_id']] = $utPreX['TsumegoStatus']['status'];
3102                    $this->Session->write('loggedInUser.uts', $sessionUts);*/
3103                }
3104            }
3105        }
3106        $boardNames = [];
3107        $enabledBoards = [];
3108        $boardPositions = [];
3109
3110        $boardNames[1] = 'Pine';
3111        $boardNames[2] = 'Ash';
3112        $boardNames[3] = 'Maple';
3113        $boardNames[4] = 'Shin Kaya';
3114        $boardNames[5] = 'Birch';
3115        $boardNames[6] = 'Wenge';
3116        $boardNames[7] = 'Walnut';
3117        $boardNames[8] = 'Mahogany';
3118        $boardNames[9] = 'Blackwood';
3119        $boardNames[10] = 'Marble 1';
3120        $boardNames[11] = 'Marble 2';
3121        $boardNames[12] = 'Marble 3';
3122        $boardNames[13] = 'Tibet Spruce';
3123        $boardNames[14] = 'Marble 4';
3124        $boardNames[15] = 'Marble 5';
3125        $boardNames[16] = 'Quarry 1';
3126        $boardNames[17] = 'Flowers';
3127        $boardNames[18] = 'Nova';
3128        $boardNames[19] = 'Spring';
3129        $boardNames[20] = 'Moon';
3130        $boardNames[21] = 'Apex';
3131        $boardNames[22] = 'Gold 1';
3132        $boardNames[23] = 'Amber';
3133        $boardNames[24] = 'Marble 6';
3134        $boardNames[25] = 'Marble 7';
3135        $boardNames[26] = 'Marble 8';
3136        $boardNames[27] = 'Marble 9';
3137        $boardNames[28] = 'Marble 10';
3138        $boardNames[29] = 'Jade';
3139        $boardNames[30] = 'Quarry 2';
3140        $boardNames[31] = 'Black Bricks';
3141        $boardNames[32] = 'Wallpaper 1';
3142        $boardNames[33] = 'Wallpaper 2';
3143        $boardNames[34] = 'Gold & Gray';
3144        $boardNames[35] = 'Gold & Pink';
3145        $boardNames[36] = 'Veil';
3146        $boardNames[37] = 'Tiles';
3147        $boardNames[38] = 'Mars';
3148        $boardNames[39] = 'Pink Cloud';
3149        $boardNames[40] = 'Reptile';
3150        $boardNames[41] = 'Mezmerizing';
3151        $boardNames[42] = 'Magenta Sky';
3152        $boardNames[43] = 'Tsumego Hero';
3153        $boardNames[44] = 'Pretty';
3154        $boardNames[45] = 'Hunting';
3155        $boardNames[46] = 'Haunted';
3156        $boardNames[47] = 'Carnage';
3157        $boardNames[48] = 'Blind Spot';
3158        $boardNames[49] = 'Giants';
3159        $boardNames[50] = 'Gems';
3160        $boardNames[51] = 'Grandmaster';
3161        $boardPositions[1] = [1, 'texture1', 'black34.png', 'white34.png'];
3162        $boardPositions[2] = [2, 'texture2', 'black34.png', 'white34.png'];
3163        $boardPositions[3] = [3, 'texture3', 'black34.png', 'white34.png'];
3164        $boardPositions[4] = [4, 'texture4', 'black.png', 'white.png'];
3165        $boardPositions[5] = [5, 'texture5', 'black34.png', 'white34.png'];
3166        $boardPositions[6] = [6, 'texture6', 'black.png', 'white.png'];
3167        $boardPositions[7] = [7, 'texture7', 'black34.png', 'white34.png'];
3168        $boardPositions[8] = [8, 'texture8', 'black.png', 'white.png'];
3169        $boardPositions[9] = [9, 'texture9', 'black.png', 'white.png'];
3170        $boardPositions[10] = [10, 'texture10', 'black34.png', 'white34.png'];
3171        $boardPositions[11] = [11, 'texture11', 'black34.png', 'white34.png'];
3172        $boardPositions[12] = [12, 'texture12', 'black34.png', 'white34.png'];
3173        $boardPositions[13] = [13, 'texture13', 'black34.png', 'white34.png'];
3174        $boardPositions[14] = [14, 'texture14', 'black34.png', 'white34.png'];
3175        $boardPositions[15] = [15, 'texture15', 'black.png', 'white.png'];
3176        $boardPositions[16] = [16, 'texture16', 'black34.png', 'white34.png'];
3177        $boardPositions[17] = [17, 'texture17', 'black34.png', 'white34.png'];
3178        $boardPositions[18] = [18, 'texture18', 'black.png', 'white.png'];
3179        $boardPositions[19] = [19, 'texture19', 'black34.png', 'white34.png'];
3180        $boardPositions[20] = [20, 'texture20', 'black34.png', 'white34.png'];
3181        $boardPositions[21] = [33, 'texture33', 'black34.png', 'white34.png'];
3182        $boardPositions[22] = [21, 'texture21', 'black.png', 'whiteKo.png'];
3183        $boardPositions[23] = [22, 'texture22', 'black34.png', 'white34.png'];
3184        $boardPositions[24] = [34, 'texture34', 'black.png', 'white.png'];
3185        $boardPositions[25] = [35, 'texture35', 'black34.png', 'white34.png'];
3186        $boardPositions[26] = [36, 'texture36', 'black.png', 'white.png'];
3187        $boardPositions[27] = [37, 'texture37', 'black34.png', 'white34.png'];
3188        $boardPositions[28] = [38, 'texture38', 'black38.png', 'white34.png'];
3189        $boardPositions[29] = [39, 'texture39', 'black.png', 'white.png'];
3190        $boardPositions[30] = [40, 'texture40', 'black34.png', 'white34.png'];
3191        $boardPositions[31] = [41, 'texture41', 'black34.png', 'white34.png'];
3192        $boardPositions[32] = [42, 'texture42', 'black34.png', 'white42.png'];
3193        $boardPositions[33] = [43, 'texture43', 'black34.png', 'white42.png'];
3194        $boardPositions[34] = [44, 'texture44', 'black34.png', 'white34.png'];
3195        $boardPositions[35] = [45, 'texture45', 'black34.png', 'white42.png'];
3196        $boardPositions[36] = [47, 'texture47', 'black34.png', 'white34.png'];
3197        $boardPositions[37] = [48, 'texture48', 'black34.png', 'white34.png'];
3198        $boardPositions[38] = [49, 'texture49', 'black.png', 'white.png'];
3199        $boardPositions[39] = [50, 'texture50', 'black34.png', 'white34.png'];
3200        $boardPositions[40] = [51, 'texture51', 'black34.png', 'white34.png'];
3201        $boardPositions[41] = [52, 'texture52', 'black34.png', 'white34.png'];
3202        $boardPositions[42] = [53, 'texture53', 'black34.png', 'white34.png'];
3203        $boardPositions[43] = [54, 'texture54', 'black54.png', 'white54.png'];
3204        $boardPositions[44] = [23, 'texture23', 'black.png', 'whiteFlower.png'];
3205        $boardPositions[45] = [24, 'texture24', 'black24.png', 'white24.png'];
3206        $boardPositions[46] = [25, 'texture25', 'blackGhost.png', 'white.png'];
3207        $boardPositions[47] = [26, 'texture26', 'blackInvis.png', 'whiteCarnage.png'];
3208        $boardPositions[48] = [27, 'texture27', 'black27.png', 'white27.png'];
3209        $boardPositions[49] = [28, 'texture28', 'blackGiant.png', 'whiteKo.png'];
3210        $boardPositions[50] = [29, 'texture29', 'blackKo.png', 'whiteKo.png'];
3211        $boardPositions[51] = [30, 'texture55', 'blackGalaxy.png', 'whiteGalaxy.png'];
3212
3213        $boardCount = 51;
3214
3215        if ($this->Session->check('texture') || (isset($_COOKIE['texture']) && $_COOKIE['texture'] != '0')) {
3216            $splitCookie = [];
3217            if (isset($_COOKIE['texture']) && $_COOKIE['texture'] != '0') {
3218                $splitCookie = str_split($_COOKIE['texture']);
3219                $textureCookies = $_COOKIE['texture'];
3220                Auth::getUser()['texture'] = $this->Session->read('texture');
3221                $this->Session->write('texture', $_COOKIE['texture']);
3222                $this->set('textureCookies', $textureCookies);
3223            } else {
3224                if (Auth::isLoggedIn()) {
3225                    $this->Session->write('texture', Auth::getUser()['texture']);
3226                }
3227                $textureCookies = $this->Session->read('texture');
3228                $splitTextureCookies = str_split($textureCookies);
3229                $splitTextureCookiesCount = count($splitTextureCookies);
3230                for ($i = 0; $i < $splitTextureCookiesCount; $i++) {
3231                    if ($splitTextureCookies[$i] == 2) {
3232                        $enabledBoards[$i + 1] = 'checked';
3233                    } else {
3234                        $enabledBoards[$i + 1] = '';
3235                    }
3236                }
3237            }
3238
3239            $splitCookieCount = count($splitCookie);
3240            for ($i = 0; $i < $splitCookieCount; $i++) {
3241                if ($splitCookie[$i] == 2) {
3242                    $enabledBoards[$i + 1] = 'checked';
3243                } else {
3244                    $enabledBoards[$i + 1] = '';
3245                }
3246            }
3247            if (Auth::isLoggedIn()) {
3248                Auth::saveUser();
3249            }
3250        }
3251
3252        if (!$this->Session->check('texture')) {
3253            $this->Session->write('texture', '222222221111111111111111111111111111111111111111111');
3254            $enabledBoards[1] = 'checked';
3255            $enabledBoards[2] = 'checked';
3256            $enabledBoards[3] = 'checked';
3257            $enabledBoards[4] = 'checked';
3258            $enabledBoards[5] = 'checked';
3259            $enabledBoards[6] = 'checked';
3260            $enabledBoards[7] = 'checked';
3261            $enabledBoards[8] = 'checked';
3262            $enabledBoards[9] = '';
3263            $enabledBoards[10] = '';
3264            $enabledBoards[11] = '';
3265            $enabledBoards[12] = '';
3266            $enabledBoards[13] = '';
3267            $enabledBoards[14] = '';
3268            $enabledBoards[15] = '';
3269            $enabledBoards[16] = '';
3270            $enabledBoards[17] = '';
3271            $enabledBoards[18] = '';
3272            $enabledBoards[19] = '';
3273            $enabledBoards[20] = '';
3274            $enabledBoards[21] = '';
3275            $enabledBoards[22] = '';
3276            $enabledBoards[23] = '';
3277            $enabledBoards[24] = '';
3278            $enabledBoards[25] = '';
3279            $enabledBoards[26] = '';
3280            $enabledBoards[27] = '';
3281            $enabledBoards[28] = '';
3282            $enabledBoards[29] = '';
3283            $enabledBoards[30] = '';
3284            $enabledBoards[31] = '';
3285            $enabledBoards[32] = '';
3286            $enabledBoards[33] = '';
3287            $enabledBoards[34] = '';
3288            $enabledBoards[35] = '';
3289            $enabledBoards[36] = '';
3290            $enabledBoards[37] = '';
3291            $enabledBoards[38] = '';
3292            $enabledBoards[39] = '';
3293            $enabledBoards[40] = '';
3294            $enabledBoards[41] = '';
3295            $enabledBoards[42] = '';
3296            $enabledBoards[43] = '';
3297            $enabledBoards[44] = '';
3298            $enabledBoards[45] = '';
3299            $enabledBoards[46] = '';
3300            $enabledBoards[47] = '';
3301            $enabledBoards[48] = '';
3302            $enabledBoards[49] = '';
3303            $enabledBoards[50] = '';
3304            $enabledBoards[51] = '';
3305        }
3306        $achievementUpdate = [];
3307        if ($this->Session->check('initialLoading')) {
3308            $achievementUpdate1 = $this->checkLevelAchievements();
3309            $achievementUpdate2 = $this->checkProblemNumberAchievements();
3310            $achievementUpdate3 = $this->checkRatingAchievements();
3311            $achievementUpdate4 = $this->checkTimeModeAchievements();
3312            $achievementUpdate5 = $this->checkDanSolveAchievements();
3313            $achievementUpdate = array_merge(
3314                $achievementUpdate1 ?: [],
3315                $achievementUpdate2 ?: [],
3316                $achievementUpdate3 ?: [],
3317                $achievementUpdate4 ?: [],
3318                $achievementUpdate5 ?: []
3319            );
3320            $this->Session->delete('initialLoading');
3321        }
3322
3323        if (count($achievementUpdate) > 0) {
3324            $this->updateXP(Auth::getUserID(), $achievementUpdate);
3325        }
3326
3327        $nextDay = new DateTime('tomorrow');
3328        if (Auth::isLoggedIn()) {
3329            Auth::getUser()['name'] = $this->checkPicture(Auth::getUser());
3330            $this->set('user', Auth::getUser());
3331        }
3332        $this->set('mode', $mode);
3333        $this->set('nextDay', $nextDay->format('m/d/Y'));
3334        $this->set('boardNames', $boardNames);
3335        $this->set('enabledBoards', $enabledBoards);
3336        $this->set('boardPositions', $boardPositions);
3337        $this->set('highscoreLink', $highscoreLink);
3338        $this->set('achievementUpdate', $achievementUpdate);
3339        $this->set('lightDark', $lightDark);
3340        $this->set('levelBar', $levelBar);
3341        $this->set('lastProfileLeft', $lastProfileLeft);
3342        $this->set('lastProfileRight', $lastProfileRight);
3343        $this->set('resetCookies', $resetCookies);
3344        $this->set('hasFavs', $hasFavs);
3345    }
3346
3347    public function afterFilter() {}
3348}